# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.523954182863236*${_u_distance}
variable latticeconst_converted equal 3.523954182863236*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52395418286324
Lattice spacing in x,y,z = 3.5239542 3.5239542 3.5239542
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.239542 35.239542 35.239542)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.239542 35.239542 35.239542)
  create_atoms CPU = 0.001 seconds

variable mass_converted equal 58.6934*${_u_mass}
variable mass_converted equal 58.6934*1

kim_interactions Ni

WARNING: 'kim_<command>' has been renamed to 'kim <command>'. Please update your input.

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_ZhouFosterSills_2018_FeNiCr__MO_036303866285_000
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

# initial volume
variable      v equal vol        # assign formula
variable      V0 equal ${v}    # evaluate initial value
variable      V0 equal 43761.3548954079    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43761.3548954079/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43761.3548954079/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43761.3548954079/(1*1*${_u_distance})
variable      V0_metal equal 43761.3548954079/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43761.3548954079*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43761.3548954079 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 293.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "293.15 - 0.2"
variable      T_up  equal  "293.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_036303866285_000#item-citation

CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17576.866   -17576.866   -17728.399   -17728.399       293.15       293.15    43761.355    43761.355    3698.4919    3698.4919 
    1000   -17409.273   -17409.273   -17570.439   -17570.439    311.78678    311.78678    44071.912    44071.912    1569.5396    1569.5396 
Loop time of 30.7422 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.810 ns/day, 8.539 hours/ns, 32.529 timesteps/s
98.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.266     | 30.266     | 30.266     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073334   | 0.073334   | 0.073334   |   0.0 |  0.24
Output  | 0.0003192  | 0.0003192  | 0.0003192  |   0.0 |  0.00
Modify  | 0.34466    | 0.34466    | 0.34466    |   0.0 |  1.12
Other   |            | 0.05815    |            |       |  0.19

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704000.0 ave      704000 max      704000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704000
Ave neighs/atom = 176.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17409.273   -17409.273   -17570.439   -17570.439    311.78678    311.78678    44071.912    44071.912    1569.5396    1569.5396 
    2000   -17423.176   -17423.176   -17572.581   -17572.581    289.03512    289.03512    44092.752    44092.752    420.75846    420.75846 
Loop time of 30.8103 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.804 ns/day, 8.558 hours/ns, 32.457 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.36      | 30.36      | 30.36      |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071024   | 0.071024   | 0.071024   |   0.0 |  0.23
Output  | 0.00013864 | 0.00013864 | 0.00013864 |   0.0 |  0.00
Modify  | 0.32596    | 0.32596    | 0.32596    |   0.0 |  1.06
Other   |            | 0.05355    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704514.0 ave      704514 max      704514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704514
Ave neighs/atom = 176.12850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17423.176   -17423.176   -17572.581   -17572.581    289.03512    289.03512    44092.752    44092.752    420.75846    420.75846 
    3000   -17417.369   -17417.369   -17572.681   -17572.681    300.46043    300.46043    44123.575    44123.575   -448.33724   -448.33724 
Loop time of 30.9283 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.794 ns/day, 8.591 hours/ns, 32.333 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.462     | 30.462     | 30.462     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07508    | 0.07508    | 0.07508    |   0.0 |  0.24
Output  | 0.00026594 | 0.00026594 | 0.00026594 |   0.0 |  0.00
Modify  | 0.33331    | 0.33331    | 0.33331    |   0.0 |  1.08
Other   |            | 0.05807    |            |       |  0.19

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704378.0 ave      704378 max      704378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704378
Ave neighs/atom = 176.09450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17417.369   -17417.369   -17572.681   -17572.681    300.46043    300.46043    44123.575    44123.575   -448.33724   -448.33724 
    4000   -17421.143   -17421.143   -17571.028   -17571.028    289.96086    289.96086    44126.482    44126.482    -677.4011    -677.4011 
Loop time of 31.345 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.756 ns/day, 8.707 hours/ns, 31.903 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.884     | 30.884     | 30.884     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072597   | 0.072597   | 0.072597   |   0.0 |  0.23
Output  | 0.00014795 | 0.00014795 | 0.00014795 |   0.0 |  0.00
Modify  | 0.33474    | 0.33474    | 0.33474    |   0.0 |  1.07
Other   |            | 0.05354    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704286.0 ave      704286 max      704286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704286
Ave neighs/atom = 176.07150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17421.143   -17421.143   -17571.028   -17571.028    289.96086    289.96086    44126.482    44126.482    -677.4011    -677.4011 
    5000   -17419.385   -17419.385   -17573.262   -17573.262    297.68492    297.68492    44130.096    44130.096   -912.74562   -912.74562 
Loop time of 31.3441 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.756 ns/day, 8.707 hours/ns, 31.904 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.881     | 30.881     | 30.881     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073336   | 0.073336   | 0.073336   |   0.0 |  0.23
Output  | 0.00010412 | 0.00010412 | 0.00010412 |   0.0 |  0.00
Modify  | 0.33565    | 0.33565    | 0.33565    |   0.0 |  1.07
Other   |            | 0.05364    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704246.0 ave      704246 max      704246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704246
Ave neighs/atom = 176.06150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 297.114337192667, Press = 588.576292187182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17419.385   -17419.385   -17573.262   -17573.262    297.68492    297.68492    44130.096    44130.096   -912.74562   -912.74562 
    6000   -17418.153   -17418.153   -17570.332   -17570.332    294.39998    294.39998    44101.246    44101.246     410.1852     410.1852 
Loop time of 31.3415 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.757 ns/day, 8.706 hours/ns, 31.907 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.849     | 30.849     | 30.849     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075282   | 0.075282   | 0.075282   |   0.0 |  0.24
Output  | 0.00010167 | 0.00010167 | 0.00010167 |   0.0 |  0.00
Modify  | 0.36017    | 0.36017    | 0.36017    |   0.0 |  1.15
Other   |            | 0.05741    |            |       |  0.18

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704194.0 ave      704194 max      704194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704194
Ave neighs/atom = 176.04850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.901196167734, Press = 81.9148624745575
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17418.153   -17418.153   -17570.332   -17570.332    294.39998    294.39998    44101.246    44101.246     410.1852     410.1852 
    7000    -17420.43    -17420.43   -17571.466   -17571.466    292.19057    292.19057    44057.445    44057.445    1870.1089    1870.1089 
Loop time of 30.7705 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.808 ns/day, 8.547 hours/ns, 32.499 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.316     | 30.316     | 30.316     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069618   | 0.069618   | 0.069618   |   0.0 |  0.23
Output  | 0.0002324  | 0.0002324  | 0.0002324  |   0.0 |  0.00
Modify  | 0.33255    | 0.33255    | 0.33255    |   0.0 |  1.08
Other   |            | 0.05245    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704432.0 ave      704432 max      704432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704432
Ave neighs/atom = 176.10800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.231295542743, Press = 37.0584113430177
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -17420.43    -17420.43   -17571.466   -17571.466    292.19057    292.19057    44057.445    44057.445    1870.1089    1870.1089 
    8000   -17419.238   -17419.238   -17571.373   -17571.373    294.31544    294.31544    44053.413    44053.413    2092.3619    2092.3619 
Loop time of 31.0157 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.786 ns/day, 8.615 hours/ns, 32.242 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.552     | 30.552     | 30.552     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072041   | 0.072041   | 0.072041   |   0.0 |  0.23
Output  | 0.00010029 | 0.00010029 | 0.00010029 |   0.0 |  0.00
Modify  | 0.33945    | 0.33945    | 0.33945    |   0.0 |  1.09
Other   |            | 0.0524     |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704592.0 ave      704592 max      704592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704592
Ave neighs/atom = 176.14800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.872264835351, Press = 10.1308136306044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17419.238   -17419.238   -17571.373   -17571.373    294.31544    294.31544    44053.413    44053.413    2092.3619    2092.3619 
    9000   -17419.501   -17419.501   -17571.674   -17571.674    294.38958    294.38958    44085.172    44085.172    888.05086    888.05086 
Loop time of 31.1612 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.773 ns/day, 8.656 hours/ns, 32.091 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.691     | 30.691     | 30.691     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073582   | 0.073582   | 0.073582   |   0.0 |  0.24
Output  | 0.00022516 | 0.00022516 | 0.00022516 |   0.0 |  0.00
Modify  | 0.34106    | 0.34106    | 0.34106    |   0.0 |  1.09
Other   |            | 0.05527    |            |       |  0.18

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704612.0 ave      704612 max      704612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704612
Ave neighs/atom = 176.15300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.986236977666, Press = 3.65729931490013
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17419.501   -17419.501   -17571.674   -17571.674    294.38958    294.38958    44085.172    44085.172    888.05086    888.05086 
   10000   -17422.257   -17422.257   -17573.284   -17573.284    292.17228    292.17228    44102.103    44102.103    3.0261083    3.0261083 
Loop time of 31.4488 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.747 ns/day, 8.736 hours/ns, 31.798 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.965     | 30.965     | 30.965     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076629   | 0.076629   | 0.076629   |   0.0 |  0.24
Output  | 9.1911e-05 | 9.1911e-05 | 9.1911e-05 |   0.0 |  0.00
Modify  | 0.35117    | 0.35117    | 0.35117    |   0.0 |  1.12
Other   |            | 0.05548    |            |       |  0.18

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704310.0 ave      704310 max      704310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704310
Ave neighs/atom = 176.07750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.84218563605, Press = 4.45339860326211
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17422.257   -17422.257   -17573.284   -17573.284    292.17228    292.17228    44102.103    44102.103    3.0261083    3.0261083 
   11000   -17423.425   -17423.425   -17572.014   -17572.014    287.45529    287.45529    44112.325    44112.325   -246.48066   -246.48066 
Loop time of 31.054 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.782 ns/day, 8.626 hours/ns, 32.202 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.57      | 30.57      | 30.57      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079393   | 0.079393   | 0.079393   |   0.0 |  0.26
Output  | 0.0001101  | 0.0001101  | 0.0001101  |   0.0 |  0.00
Modify  | 0.34387    | 0.34387    | 0.34387    |   0.0 |  1.11
Other   |            | 0.0609     |            |       |  0.20

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704436.0 ave      704436 max      704436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704436
Ave neighs/atom = 176.10900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.847018826221, Press = 5.02435858132252
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17423.425   -17423.425   -17572.014   -17572.014    287.45529    287.45529    44112.325    44112.325   -246.48066   -246.48066 
   12000   -17419.182   -17419.182   -17572.859   -17572.859    297.29805    297.29805    44116.619    44116.619   -390.85294   -390.85294 
Loop time of 30.5411 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.829 ns/day, 8.484 hours/ns, 32.743 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.092     | 30.092     | 30.092     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069925   | 0.069925   | 0.069925   |   0.0 |  0.23
Output  | 0.00010507 | 0.00010507 | 0.00010507 |   0.0 |  0.00
Modify  | 0.33046    | 0.33046    | 0.33046    |   0.0 |  1.08
Other   |            | 0.04878    |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704360.0 ave      704360 max      704360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704360
Ave neighs/atom = 176.09000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.842851224398, Press = 5.15684064444082
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17419.182   -17419.182   -17572.859   -17572.859    297.29805    297.29805    44116.619    44116.619   -390.85294   -390.85294 
   13000   -17416.029   -17416.029   -17571.006   -17571.006    299.81356    299.81356    44115.917    44115.917   -282.28986   -282.28986 
Loop time of 30.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.795 ns/day, 8.586 hours/ns, 32.353 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.448     | 30.448     | 30.448     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071274   | 0.071274   | 0.071274   |   0.0 |  0.23
Output  | 0.00023687 | 0.00023687 | 0.00023687 |   0.0 |  0.00
Modify  | 0.3382     | 0.3382     | 0.3382     |   0.0 |  1.09
Other   |            | 0.05109    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704242.0 ave      704242 max      704242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704242
Ave neighs/atom = 176.06050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.780507240657, Press = 5.57358903525521
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17416.029   -17416.029   -17571.006   -17571.006    299.81356    299.81356    44115.917    44115.917   -282.28986   -282.28986 
   14000   -17421.784   -17421.784   -17573.536   -17573.536    293.57399    293.57399    44077.272    44077.272    978.85268    978.85268 
Loop time of 31.435 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.749 ns/day, 8.732 hours/ns, 31.812 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.936     | 30.936     | 30.936     |   0.0 | 98.41
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078661   | 0.078661   | 0.078661   |   0.0 |  0.25
Output  | 0.00092789 | 0.00092789 | 0.00092789 |   0.0 |  0.00
Modify  | 0.35934    | 0.35934    | 0.35934    |   0.0 |  1.14
Other   |            | 0.06021    |            |       |  0.19

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704278.0 ave      704278 max      704278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704278
Ave neighs/atom = 176.06950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.826767563766, Press = 4.30451622586595
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17421.784   -17421.784   -17573.536   -17573.536    293.57399    293.57399    44077.272    44077.272    978.85268    978.85268 
   15000    -17416.59    -17416.59   -17569.795   -17569.795    296.38615    296.38615    44074.579    44074.579     1462.365     1462.365 
Loop time of 31.0914 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.779 ns/day, 8.636 hours/ns, 32.163 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.619     | 30.619     | 30.619     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074602   | 0.074602   | 0.074602   |   0.0 |  0.24
Output  | 0.00010422 | 0.00010422 | 0.00010422 |   0.0 |  0.00
Modify  | 0.34239    | 0.34239    | 0.34239    |   0.0 |  1.10
Other   |            | 0.05554    |            |       |  0.18

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704618.0 ave      704618 max      704618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704618
Ave neighs/atom = 176.15450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.83019185343, Press = 1.20352185747277
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -17416.59    -17416.59   -17569.795   -17569.795    296.38615    296.38615    44074.579    44074.579     1462.365     1462.365 
   16000   -17421.755   -17421.755   -17571.988   -17571.988    290.63503    290.63503    44103.888    44103.888    145.20528    145.20528 
Loop time of 30.4739 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.835 ns/day, 8.465 hours/ns, 32.815 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.029     | 30.029     | 30.029     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068082   | 0.068082   | 0.068082   |   0.0 |  0.22
Output  | 0.00021416 | 0.00021416 | 0.00021416 |   0.0 |  0.00
Modify  | 0.32528    | 0.32528    | 0.32528    |   0.0 |  1.07
Other   |            | 0.05091    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704496.0 ave      704496 max      704496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704496
Ave neighs/atom = 176.12400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.016767309828, Press = -1.69199311103903
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17421.755   -17421.755   -17571.988   -17571.988    290.63503    290.63503    44103.888    44103.888    145.20528    145.20528 
   17000   -17419.667   -17419.667   -17571.639   -17571.639    293.99928    293.99928    44146.048    44146.048   -1446.8026   -1446.8026 
Loop time of 30.9707 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.790 ns/day, 8.603 hours/ns, 32.289 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.512     | 30.512     | 30.512     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069925   | 0.069925   | 0.069925   |   0.0 |  0.23
Output  | 0.00010008 | 0.00010008 | 0.00010008 |   0.0 |  0.00
Modify  | 0.33723    | 0.33723    | 0.33723    |   0.0 |  1.09
Other   |            | 0.05171    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704184.0 ave      704184 max      704184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704184
Ave neighs/atom = 176.04600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.045063582387, Press = -2.34029844683736
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17419.667   -17419.667   -17571.639   -17571.639    293.99928    293.99928    44146.048    44146.048   -1446.8026   -1446.8026 
   18000   -17418.832   -17418.832   -17570.971   -17570.971    294.32355    294.32355    44176.753    44176.753   -2583.3678   -2583.3678 
Loop time of 30.9442 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.792 ns/day, 8.596 hours/ns, 32.316 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.486     | 30.486     | 30.486     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069911   | 0.069911   | 0.069911   |   0.0 |  0.23
Output  | 0.00018748 | 0.00018748 | 0.00018748 |   0.0 |  0.00
Modify  | 0.33577    | 0.33577    | 0.33577    |   0.0 |  1.09
Other   |            | 0.05261    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704176.0 ave      704176 max      704176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704176
Ave neighs/atom = 176.04400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.907157030576, Press = 0.783217978840331
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17418.832   -17418.832   -17570.971   -17570.971    294.32355    294.32355    44176.753    44176.753   -2583.3678   -2583.3678 
   19000   -17422.697   -17422.697     -17570.7     -17570.7    286.32296    286.32296    44132.863    44132.863   -961.58475   -961.58475 
Loop time of 30.8076 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.805 ns/day, 8.558 hours/ns, 32.460 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.358     | 30.358     | 30.358     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068271   | 0.068271   | 0.068271   |   0.0 |  0.22
Output  | 9.3605e-05 | 9.3605e-05 | 9.3605e-05 |   0.0 |  0.00
Modify  | 0.33297    | 0.33297    | 0.33297    |   0.0 |  1.08
Other   |            | 0.04859    |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704040.0 ave      704040 max      704040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704040
Ave neighs/atom = 176.01000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.859122492159, Press = 3.15667751250313
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17422.697   -17422.697     -17570.7     -17570.7    286.32296    286.32296    44132.863    44132.863   -961.58475   -961.58475 
   20000   -17419.198   -17419.198   -17569.938   -17569.938    291.61638    291.61638    44118.215    44118.215   -290.57022   -290.57022 
Loop time of 30.2944 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.852 ns/day, 8.415 hours/ns, 33.009 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.857     | 29.857     | 29.857     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066417   | 0.066417   | 0.066417   |   0.0 |  0.22
Output  | 8.9553e-05 | 8.9553e-05 | 8.9553e-05 |   0.0 |  0.00
Modify  | 0.32449    | 0.32449    | 0.32449    |   0.0 |  1.07
Other   |            | 0.04592    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704234.0 ave      704234 max      704234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704234
Ave neighs/atom = 176.05850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.894223254439, Press = 3.33852135875631
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17419.198   -17419.198   -17569.938   -17569.938    291.61638    291.61638    44118.215    44118.215   -290.57022   -290.57022 
   21000    -17422.54    -17422.54   -17573.934   -17573.934     292.8826     292.8826     44104.99     44104.99   -110.55372   -110.55372 
Loop time of 29.8148 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.898 ns/day, 8.282 hours/ns, 33.540 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.385     | 29.385     | 29.385     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067248   | 0.067248   | 0.067248   |   0.0 |  0.23
Output  | 0.00018536 | 0.00018536 | 0.00018536 |   0.0 |  0.00
Modify  | 0.31275    | 0.31275    | 0.31275    |   0.0 |  1.05
Other   |            | 0.05008    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704272.0 ave      704272 max      704272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704272
Ave neighs/atom = 176.06800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.846184502956, Press = 3.64132326913394
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    -17422.54    -17422.54   -17573.934   -17573.934     292.8826     292.8826     44104.99     44104.99   -110.55372   -110.55372 
   22000   -17419.244   -17419.244   -17570.268   -17570.268    292.16712    292.16712    44090.657    44090.657    755.57939    755.57939 
Loop time of 30.4309 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.839 ns/day, 8.453 hours/ns, 32.861 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.98      | 29.98      | 29.98      |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072296   | 0.072296   | 0.072296   |   0.0 |  0.24
Output  | 9.8175e-05 | 9.8175e-05 | 9.8175e-05 |   0.0 |  0.00
Modify  | 0.32664    | 0.32664    | 0.32664    |   0.0 |  1.07
Other   |            | 0.05202    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704258.0 ave      704258 max      704258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704258
Ave neighs/atom = 176.06450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.815545148735, Press = 4.17782731578139
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17419.244   -17419.244   -17570.268   -17570.268    292.16712    292.16712    44090.657    44090.657    755.57939    755.57939 
   23000   -17423.308   -17423.308   -17576.126   -17576.126    295.63614    295.63614     44017.39     44017.39    3157.1704    3157.1704 
Loop time of 30.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.809 ns/day, 8.545 hours/ns, 32.507 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.308     | 30.308     | 30.308     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070055   | 0.070055   | 0.070055   |   0.0 |  0.23
Output  | 9.7287e-05 | 9.7287e-05 | 9.7287e-05 |   0.0 |  0.00
Modify  | 0.33445    | 0.33445    | 0.33445    |   0.0 |  1.09
Other   |            | 0.05081    |            |       |  0.17

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704282.0 ave      704282 max      704282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704282
Ave neighs/atom = 176.07050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.714174508109, Press = 3.39180965238894
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17423.308   -17423.308   -17576.126   -17576.126    295.63614    295.63614     44017.39     44017.39    3157.1704    3157.1704 
   24000   -17418.848   -17418.848   -17573.559   -17573.559    299.29903    299.29903    44062.071    44062.071    1665.2675    1665.2675 
Loop time of 29.8728 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.892 ns/day, 8.298 hours/ns, 33.475 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.454     | 29.454     | 29.454     |   0.0 | 98.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064314   | 0.064314   | 0.064314   |   0.0 |  0.22
Output  | 0.00021194 | 0.00021194 | 0.00021194 |   0.0 |  0.00
Modify  | 0.3108     | 0.3108     | 0.3108     |   0.0 |  1.04
Other   |            | 0.04316    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704860.0 ave      704860 max      704860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704860
Ave neighs/atom = 176.21500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.697956447532, Press = 0.395865098333316
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17418.848   -17418.848   -17573.559   -17573.559    299.29903    299.29903    44062.071    44062.071    1665.2675    1665.2675 
   25000       -17423       -17423   -17573.424   -17573.424     291.0066     291.0066     44096.22     44096.22    327.02364    327.02364 
Loop time of 30.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.863 ns/day, 8.384 hours/ns, 33.131 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.753     | 29.753     | 29.753     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065439   | 0.065439   | 0.065439   |   0.0 |  0.22
Output  | 9.3541e-05 | 9.3541e-05 | 9.3541e-05 |   0.0 |  0.00
Modify  | 0.31749    | 0.31749    | 0.31749    |   0.0 |  1.05
Other   |            | 0.04668    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704600.0 ave      704600 max      704600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704600
Ave neighs/atom = 176.15000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.628540772779, Press = -0.20935150045445
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000       -17423       -17423   -17573.424   -17573.424     291.0066     291.0066     44096.22     44096.22    327.02364    327.02364 
   26000   -17417.582   -17417.582   -17569.301   -17569.301    293.51029    293.51029     44134.03     44134.03   -874.01594   -874.01594 
Loop time of 30.3341 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.848 ns/day, 8.426 hours/ns, 32.966 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.897     | 29.897     | 29.897     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067031   | 0.067031   | 0.067031   |   0.0 |  0.22
Output  | 9.8087e-05 | 9.8087e-05 | 9.8087e-05 |   0.0 |  0.00
Modify  | 0.32346    | 0.32346    | 0.32346    |   0.0 |  1.07
Other   |            | 0.04677    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704310.0 ave      704310 max      704310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704310
Ave neighs/atom = 176.07750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.615594455592, Press = 0.553450636382135
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17417.582   -17417.582   -17569.301   -17569.301    293.51029    293.51029     44134.03     44134.03   -874.01594   -874.01594 
   27000   -17419.948   -17419.948   -17568.935   -17568.935    288.22627    288.22627     44139.64     44139.64    -1063.881    -1063.881 
Loop time of 30.2269 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.858 ns/day, 8.396 hours/ns, 33.083 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.79      | 29.79      | 29.79      |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067278   | 0.067278   | 0.067278   |   0.0 |  0.22
Output  | 0.00020756 | 0.00020756 | 0.00020756 |   0.0 |  0.00
Modify  | 0.3223     | 0.3223     | 0.3223     |   0.0 |  1.07
Other   |            | 0.04707    |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704188.0 ave      704188 max      704188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704188
Ave neighs/atom = 176.04700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.58755865274, Press = 0.984198896965496
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17419.948   -17419.948   -17568.935   -17568.935    288.22627    288.22627     44139.64     44139.64    -1063.881    -1063.881 
   28000   -17424.129   -17424.129   -17570.162   -17570.162    282.51067    282.51067    44187.383    44187.383   -3032.5428   -3032.5428 
Loop time of 30.1499 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.866 ns/day, 8.375 hours/ns, 33.168 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.716     | 29.716     | 29.716     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065958   | 0.065958   | 0.065958   |   0.0 |  0.22
Output  | 8.8275e-05 | 8.8275e-05 | 8.8275e-05 |   0.0 |  0.00
Modify  | 0.32182    | 0.32182    | 0.32182    |   0.0 |  1.07
Other   |            | 0.04591    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704022.0 ave      704022 max      704022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704022
Ave neighs/atom = 176.00550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.635526621902, Press = 2.49455408257923
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17424.129   -17424.129   -17570.162   -17570.162    282.51067    282.51067    44187.383    44187.383   -3032.5428   -3032.5428 
   29000    -17418.53    -17418.53   -17569.674   -17569.674    292.39678    292.39678     44147.78     44147.78   -1469.4923   -1469.4923 
Loop time of 30.3085 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.851 ns/day, 8.419 hours/ns, 32.994 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.866     | 29.866     | 29.866     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068902   | 0.068902   | 0.068902   |   0.0 |  0.23
Output  | 0.00010502 | 0.00010502 | 0.00010502 |   0.0 |  0.00
Modify  | 0.32479    | 0.32479    | 0.32479    |   0.0 |  1.07
Other   |            | 0.04898    |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      703920.0 ave      703920 max      703920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 703920
Ave neighs/atom = 175.98000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.572694326042, Press = 4.91711858739203
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -17418.53    -17418.53   -17569.674   -17569.674    292.39678    292.39678     44147.78     44147.78   -1469.4923   -1469.4923 
   30000   -17420.943   -17420.943   -17571.351   -17571.351     290.9748     290.9748    44083.341    44083.341    1033.6833    1033.6833 
Loop time of 29.9947 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.881 ns/day, 8.332 hours/ns, 33.339 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.562     | 29.562     | 29.562     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067072   | 0.067072   | 0.067072   |   0.0 |  0.22
Output  | 9.6199e-05 | 9.6199e-05 | 9.6199e-05 |   0.0 |  0.00
Modify  | 0.31884    | 0.31884    | 0.31884    |   0.0 |  1.06
Other   |            | 0.047      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704090.0 ave      704090 max      704090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704090
Ave neighs/atom = 176.02250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.60102234937, Press = 3.69162030156588
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17420.943   -17420.943   -17571.351   -17571.351     290.9748     290.9748    44083.341    44083.341    1033.6833    1033.6833 
   31000   -17418.509   -17418.509     -17573.2     -17573.2    299.26047    299.26047     44073.39     44073.39    1323.2632    1323.2632 
Loop time of 30.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.862 ns/day, 8.384 hours/ns, 33.130 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.745     | 29.745     | 29.745     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069012   | 0.069012   | 0.069012   |   0.0 |  0.23
Output  | 8.9202e-05 | 8.9202e-05 | 8.9202e-05 |   0.0 |  0.00
Modify  | 0.32054    | 0.32054    | 0.32054    |   0.0 |  1.06
Other   |            | 0.04901    |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704462.0 ave      704462 max      704462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704462
Ave neighs/atom = 176.11550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.580073015661, Press = 2.52695784506048
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17418.509   -17418.509     -17573.2     -17573.2    299.26047    299.26047     44073.39     44073.39    1323.2632    1323.2632 
   32000   -17419.115   -17419.115   -17574.392   -17574.392    300.39283    300.39283    44073.593    44073.593    1171.3677    1171.3677 
Loop time of 29.5681 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.922 ns/day, 8.213 hours/ns, 33.820 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.157     | 29.157     | 29.157     |   0.0 | 98.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063833   | 0.063833   | 0.063833   |   0.0 |  0.22
Output  | 9.4562e-05 | 9.4562e-05 | 9.4562e-05 |   0.0 |  0.00
Modify  | 0.30531    | 0.30531    | 0.30531    |   0.0 |  1.03
Other   |            | 0.04198    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704410.0 ave      704410 max      704410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704410
Ave neighs/atom = 176.10250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.569154305513, Press = 1.55546148218414
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17419.115   -17419.115   -17574.392   -17574.392    300.39283    300.39283    44073.593    44073.593    1171.3677    1171.3677 
   33000   -17420.623   -17420.623   -17573.946   -17573.946    296.61307    296.61307    44084.603    44084.603     819.6073     819.6073 
Loop time of 30.3814 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.844 ns/day, 8.439 hours/ns, 32.915 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.947     | 29.947     | 29.947     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0659     | 0.0659     | 0.0659     |   0.0 |  0.22
Output  | 7.3085e-05 | 7.3085e-05 | 7.3085e-05 |   0.0 |  0.00
Modify  | 0.32303    | 0.32303    | 0.32303    |   0.0 |  1.06
Other   |            | 0.045      |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704442.0 ave      704442 max      704442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704442
Ave neighs/atom = 176.11050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.527439855874, Press = 1.13086644953759
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17420.623   -17420.623   -17573.946   -17573.946    296.61307    296.61307    44084.603    44084.603     819.6073     819.6073 
   34000   -17416.986   -17416.986    -17569.34    -17569.34    294.73931    294.73931    44100.193    44100.193     481.5794     481.5794 
Loop time of 29.9777 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.882 ns/day, 8.327 hours/ns, 33.358 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.549     | 29.549     | 29.549     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065821   | 0.065821   | 0.065821   |   0.0 |  0.22
Output  | 8.6972e-05 | 8.6972e-05 | 8.6972e-05 |   0.0 |  0.00
Modify  | 0.31723    | 0.31723    | 0.31723    |   0.0 |  1.06
Other   |            | 0.04566    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704294.0 ave      704294 max      704294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704294
Ave neighs/atom = 176.07350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.503575532398, Press = 0.851080409342984
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17416.986   -17416.986    -17569.34    -17569.34    294.73931    294.73931    44100.193    44100.193     481.5794     481.5794 
   35000   -17424.653   -17424.653   -17573.931   -17573.931    288.78755    288.78755    44096.869    44096.869    147.76653    147.76653 
Loop time of 30.2938 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.852 ns/day, 8.415 hours/ns, 33.010 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.858     | 29.858     | 29.858     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066608   | 0.066608   | 0.066608   |   0.0 |  0.22
Output  | 6.8895e-05 | 6.8895e-05 | 6.8895e-05 |   0.0 |  0.00
Modify  | 0.32118    | 0.32118    | 0.32118    |   0.0 |  1.06
Other   |            | 0.04795    |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704254.0 ave      704254 max      704254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704254
Ave neighs/atom = 176.06350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.47616465636, Press = 0.482192254551507
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17424.653   -17424.653   -17573.931   -17573.931    288.78755    288.78755    44096.869    44096.869    147.76653    147.76653 
   36000   -17419.054   -17419.054   -17570.713   -17570.713    293.39503    293.39503    44133.829    44133.829   -865.34444   -865.34444 
Loop time of 29.71 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.908 ns/day, 8.253 hours/ns, 33.659 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.294     | 29.294     | 29.294     |   0.0 | 98.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063548   | 0.063548   | 0.063548   |   0.0 |  0.21
Output  | 9.4576e-05 | 9.4576e-05 | 9.4576e-05 |   0.0 |  0.00
Modify  | 0.30787    | 0.30787    | 0.30787    |   0.0 |  1.04
Other   |            | 0.04435    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704346.0 ave      704346 max      704346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704346
Ave neighs/atom = 176.08650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.460338749059, Press = -0.116054117744989
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17419.054   -17419.054   -17570.713   -17570.713    293.39503    293.39503    44133.829    44133.829   -865.34444   -865.34444 
   37000   -17421.271   -17421.271   -17570.589   -17570.589    288.86581    288.86581    44168.329    44168.329   -2290.0818   -2290.0818 
Loop time of 29.2238 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.956 ns/day, 8.118 hours/ns, 34.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.821     | 28.821     | 28.821     |   0.0 | 98.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062669   | 0.062669   | 0.062669   |   0.0 |  0.21
Output  | 8.2137e-05 | 8.2137e-05 | 8.2137e-05 |   0.0 |  0.00
Modify  | 0.29863    | 0.29863    | 0.29863    |   0.0 |  1.02
Other   |            | 0.04094    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704324.0 ave      704324 max      704324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704324
Ave neighs/atom = 176.08100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.486347622837, Press = 0.469132078547515
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17421.271   -17421.271   -17570.589   -17570.589    288.86581    288.86581    44168.329    44168.329   -2290.0818   -2290.0818 
   38000    -17415.14    -17415.14   -17570.738   -17570.738    301.01561    301.01561    44160.253    44160.253   -1812.7569   -1812.7569 
Loop time of 29.1863 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.960 ns/day, 8.107 hours/ns, 34.263 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.786     | 28.786     | 28.786     |   0.0 | 98.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062315   | 0.062315   | 0.062315   |   0.0 |  0.21
Output  | 9.4029e-05 | 9.4029e-05 | 9.4029e-05 |   0.0 |  0.00
Modify  | 0.2972     | 0.2972     | 0.2972     |   0.0 |  1.02
Other   |            | 0.04064    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      703896.0 ave      703896 max      703896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 703896
Ave neighs/atom = 175.97400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.53141744961, Press = 1.68395786997692
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -17415.14    -17415.14   -17570.738   -17570.738    301.01561    301.01561    44160.253    44160.253   -1812.7569   -1812.7569 
   39000   -17420.044   -17420.044   -17571.802   -17571.802    293.58651    293.58651    44111.212    44111.212    -178.2813    -178.2813 
Loop time of 29.0694 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.972 ns/day, 8.075 hours/ns, 34.400 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.674     | 28.674     | 28.674     |   0.0 | 98.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061617   | 0.061617   | 0.061617   |   0.0 |  0.21
Output  | 6.5764e-05 | 6.5764e-05 | 6.5764e-05 |   0.0 |  0.00
Modify  | 0.29425    | 0.29425    | 0.29425    |   0.0 |  1.01
Other   |            | 0.03988    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704000.0 ave      704000 max      704000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704000
Ave neighs/atom = 176.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.575484533163, Press = 1.80534559179585
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17420.044   -17420.044   -17571.802   -17571.802    293.58651    293.58651    44111.212    44111.212    -178.2813    -178.2813 
   40000    -17415.55    -17415.55   -17570.907   -17570.907    300.54749    300.54749    44102.077    44102.077    378.29169    378.29169 
Loop time of 29.2274 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.956 ns/day, 8.119 hours/ns, 34.214 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.826     | 28.826     | 28.826     |   0.0 | 98.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062357   | 0.062357   | 0.062357   |   0.0 |  0.21
Output  | 7.1221e-05 | 7.1221e-05 | 7.1221e-05 |   0.0 |  0.00
Modify  | 0.29852    | 0.29852    | 0.29852    |   0.0 |  1.02
Other   |            | 0.04059    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704340.0 ave      704340 max      704340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704340
Ave neighs/atom = 176.08500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.636462998476, Press = 1.10465609329661
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    -17415.55    -17415.55   -17570.907   -17570.907    300.54749    300.54749    44102.077    44102.077    378.29169    378.29169 
   41000   -17419.575   -17419.575   -17571.945   -17571.945    294.77053    294.77053    44100.849    44100.849    261.54376    261.54376 
Loop time of 28.9971 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.980 ns/day, 8.055 hours/ns, 34.486 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.602     | 28.602     | 28.602     |   0.0 | 98.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061881   | 0.061881   | 0.061881   |   0.0 |  0.21
Output  | 7.069e-05  | 7.069e-05  | 7.069e-05  |   0.0 |  0.00
Modify  | 0.29316    | 0.29316    | 0.29316    |   0.0 |  1.01
Other   |            | 0.03965    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704360.0 ave      704360 max      704360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704360
Ave neighs/atom = 176.09000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.628007358136, Press = 1.0680873784768
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17419.575   -17419.575   -17571.945   -17571.945    294.77053    294.77053    44100.849    44100.849    261.54376    261.54376 
   42000   -17424.259   -17424.259   -17572.298   -17572.298    286.39293    286.39293    44102.749    44102.749    47.549328    47.549328 
Loop time of 29.2195 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.957 ns/day, 8.117 hours/ns, 34.224 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.819     | 28.819     | 28.819     |   0.0 | 98.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062292   | 0.062292   | 0.062292   |   0.0 |  0.21
Output  | 9.5037e-05 | 9.5037e-05 | 9.5037e-05 |   0.0 |  0.00
Modify  | 0.29789    | 0.29789    | 0.29789    |   0.0 |  1.02
Other   |            | 0.04024    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704458.0 ave      704458 max      704458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704458
Ave neighs/atom = 176.11450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.61544642009, Press = 0.783360117112295
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17424.259   -17424.259   -17572.298   -17572.298    286.39293    286.39293    44102.749    44102.749    47.549328    47.549328 
   43000    -17416.99    -17416.99   -17569.106   -17569.106    294.27939    294.27939    44111.807    44111.807    52.023309    52.023309 
Loop time of 29.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.943 ns/day, 8.156 hours/ns, 34.059 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.957     | 28.957     | 28.957     |   0.0 | 98.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062535   | 0.062535   | 0.062535   |   0.0 |  0.21
Output  | 6.7516e-05 | 6.7516e-05 | 6.7516e-05 |   0.0 |  0.00
Modify  | 0.3        | 0.3        | 0.3        |   0.0 |  1.02
Other   |            | 0.04086    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704154.0 ave      704154 max      704154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704154
Ave neighs/atom = 176.03850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.594007593886, Press = 0.574314042846456
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000    -17416.99    -17416.99   -17569.106   -17569.106    294.27939    294.27939    44111.807    44111.807    52.023309    52.023309 
   44000    -17416.72    -17416.72   -17568.514   -17568.514    293.65504    293.65504    44133.831    44133.831   -732.21843   -732.21843 
Loop time of 29.5631 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.923 ns/day, 8.212 hours/ns, 33.826 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.152     | 29.152     | 29.152     |   0.0 | 98.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063166   | 0.063166   | 0.063166   |   0.0 |  0.21
Output  | 9.4022e-05 | 9.4022e-05 | 9.4022e-05 |   0.0 |  0.00
Modify  | 0.30577    | 0.30577    | 0.30577    |   0.0 |  1.03
Other   |            | 0.04165    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704308.0 ave      704308 max      704308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704308
Ave neighs/atom = 176.07700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.6150953448, Press = 0.488294931419485
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000    -17416.72    -17416.72   -17568.514   -17568.514    293.65504    293.65504    44133.831    44133.831   -732.21843   -732.21843 
   45000   -17421.029   -17421.029   -17572.972   -17572.972    293.94371    293.94371    44142.199    44142.199   -1402.9512   -1402.9512 
Loop time of 29.6326 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.916 ns/day, 8.231 hours/ns, 33.747 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.219     | 29.219     | 29.219     |   0.0 | 98.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063567   | 0.063567   | 0.063567   |   0.0 |  0.21
Output  | 7.0505e-05 | 7.0505e-05 | 7.0505e-05 |   0.0 |  0.00
Modify  | 0.30795    | 0.30795    | 0.30795    |   0.0 |  1.04
Other   |            | 0.04201    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704158.0 ave      704158 max      704158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704158
Ave neighs/atom = 176.03950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.667554738445, Press = 0.689690304216151
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17421.029   -17421.029   -17572.972   -17572.972    293.94371    293.94371    44142.199    44142.199   -1402.9512   -1402.9512 
   46000    -17415.61    -17415.61   -17567.298   -17567.298    293.45024    293.45024    44158.465    44158.465   -1534.8303   -1534.8303 
Loop time of 29.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.907 ns/day, 8.255 hours/ns, 33.651 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.305     | 29.305     | 29.305     |   0.0 | 98.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063686   | 0.063686   | 0.063686   |   0.0 |  0.21
Output  | 7.0829e-05 | 7.0829e-05 | 7.0829e-05 |   0.0 |  0.00
Modify  | 0.30703    | 0.30703    | 0.30703    |   0.0 |  1.03
Other   |            | 0.04164    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704102.0 ave      704102 max      704102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704102
Ave neighs/atom = 176.02550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.718459693943, Press = 1.98066275403216
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000    -17415.61    -17415.61   -17567.298   -17567.298    293.45024    293.45024    44158.465    44158.465   -1534.8303   -1534.8303 
   47000   -17420.613   -17420.613   -17570.864   -17570.864    290.66924    290.66924    44110.046    44110.046   -12.218786   -12.218786 
Loop time of 29.2903 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.950 ns/day, 8.136 hours/ns, 34.141 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.887     | 28.887     | 28.887     |   0.0 | 98.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062751   | 0.062751   | 0.062751   |   0.0 |  0.21
Output  | 6.6688e-05 | 6.6688e-05 | 6.6688e-05 |   0.0 |  0.00
Modify  | 0.29986    | 0.29986    | 0.29986    |   0.0 |  1.02
Other   |            | 0.04108    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704048.0 ave      704048 max      704048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704048
Ave neighs/atom = 176.01200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.735743687174, Press = 2.42055201478658
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17420.613   -17420.613   -17570.864   -17570.864    290.66924    290.66924    44110.046    44110.046   -12.218786   -12.218786 
   48000   -17413.565   -17413.565   -17568.041   -17568.041    298.84474    298.84474    44093.798    44093.798    907.55153    907.55153 
Loop time of 29.9771 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.882 ns/day, 8.327 hours/ns, 33.359 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.554     | 29.554     | 29.554     |   0.0 | 98.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064429   | 0.064429   | 0.064429   |   0.0 |  0.21
Output  | 0.00010934 | 0.00010934 | 0.00010934 |   0.0 |  0.00
Modify  | 0.3139     | 0.3139     | 0.3139     |   0.0 |  1.05
Other   |            | 0.04482    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704402.0 ave      704402 max      704402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704402
Ave neighs/atom = 176.10050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.789657927045, Press = 1.41598332649797
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17413.565   -17413.565   -17568.041   -17568.041    298.84474    298.84474    44093.798    44093.798    907.55153    907.55153 
   49000   -17420.411   -17420.411   -17571.563   -17571.563    292.41321    292.41321    44097.379    44097.379      416.071      416.071 
Loop time of 29.2232 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.957 ns/day, 8.118 hours/ns, 34.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.825     | 28.825     | 28.825     |   0.0 | 98.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062287   | 0.062287   | 0.062287   |   0.0 |  0.21
Output  | 8.4492e-05 | 8.4492e-05 | 8.4492e-05 |   0.0 |  0.00
Modify  | 0.29558    | 0.29558    | 0.29558    |   0.0 |  1.01
Other   |            | 0.03986    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704346.0 ave      704346 max      704346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704346
Ave neighs/atom = 176.08650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.816171360291, Press = 0.687807949797405
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -17420.411   -17420.411   -17571.563   -17571.563    292.41321    292.41321    44097.379    44097.379      416.071      416.071 
   50000   -17420.622   -17420.622   -17569.393   -17569.393    287.80915    287.80915    44112.357    44112.357   -81.300687   -81.300687 
Loop time of 28.9167 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.988 ns/day, 8.032 hours/ns, 34.582 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.527     | 28.527     | 28.527     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06132    | 0.06132    | 0.06132    |   0.0 |  0.21
Output  | 8.1702e-05 | 8.1702e-05 | 8.1702e-05 |   0.0 |  0.00
Modify  | 0.28953    | 0.28953    | 0.28953    |   0.0 |  1.00
Other   |            | 0.03884    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704468.0 ave      704468 max      704468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704468
Ave neighs/atom = 176.11700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.857490126686, Press = 0.339983297029127
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17420.622   -17420.622   -17569.393   -17569.393    287.80915    287.80915    44112.357    44112.357   -81.300687   -81.300687 
   51000   -17419.641   -17419.641    -17570.96    -17570.96    292.73637    292.73637    44154.036    44154.036   -1677.0615   -1677.0615 
Loop time of 28.9606 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.983 ns/day, 8.045 hours/ns, 34.530 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.57      | 28.57      | 28.57      |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061443   | 0.061443   | 0.061443   |   0.0 |  0.21
Output  | 0.0001047  | 0.0001047  | 0.0001047  |   0.0 |  0.00
Modify  | 0.29056    | 0.29056    | 0.29056    |   0.0 |  1.00
Other   |            | 0.03867    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704196.0 ave      704196 max      704196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704196
Ave neighs/atom = 176.04900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.825382389712, Press = 0.514871692432476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -17419.641   -17419.641    -17570.96    -17570.96    292.73637    292.73637    44154.036    44154.036   -1677.0615   -1677.0615 
   52000   -17421.413   -17421.413   -17571.956   -17571.956    291.23736    291.23736    44176.459    44176.459   -2611.0839   -2611.0839 
Loop time of 28.9375 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.986 ns/day, 8.038 hours/ns, 34.557 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.547     | 28.547     | 28.547     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061467   | 0.061467   | 0.061467   |   0.0 |  0.21
Output  | 8.943e-05  | 8.943e-05  | 8.943e-05  |   0.0 |  0.00
Modify  | 0.28979    | 0.28979    | 0.28979    |   0.0 |  1.00
Other   |            | 0.03901    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704092.0 ave      704092 max      704092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704092
Ave neighs/atom = 176.02300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.825968448639, Press = 1.46858963329811
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -17421.413   -17421.413   -17571.956   -17571.956    291.23736    291.23736    44176.459    44176.459   -2611.0839   -2611.0839 
   53000   -17419.452   -17419.452   -17570.248   -17570.248    291.72607    291.72607    44121.753    44121.753   -427.91061   -427.91061 
Loop time of 28.9439 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.985 ns/day, 8.040 hours/ns, 34.550 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.555     | 28.555     | 28.555     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061058   | 0.061058   | 0.061058   |   0.0 |  0.21
Output  | 6.5617e-05 | 6.5617e-05 | 6.5617e-05 |   0.0 |  0.00
Modify  | 0.28932    | 0.28932    | 0.28932    |   0.0 |  1.00
Other   |            | 0.03895    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704002.0 ave      704002 max      704002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704002
Ave neighs/atom = 176.00050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.792920491789, Press = 1.62982663174671
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -17419.452   -17419.452   -17570.248   -17570.248    291.72607    291.72607    44121.753    44121.753   -427.91061   -427.91061 
   54000   -17423.951   -17423.951   -17573.635   -17573.635     289.5747     289.5747    44090.596    44090.596    531.89671    531.89671 
Loop time of 28.9432 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.985 ns/day, 8.040 hours/ns, 34.550 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.554     | 28.554     | 28.554     |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061215   | 0.061215   | 0.061215   |   0.0 |  0.21
Output  | 9.4426e-05 | 9.4426e-05 | 9.4426e-05 |   0.0 |  0.00
Modify  | 0.28908    | 0.28908    | 0.28908    |   0.0 |  1.00
Other   |            | 0.0387     |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704236.0 ave      704236 max      704236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704236
Ave neighs/atom = 176.05900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.785407200036, Press = 1.11637830730204
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -17423.951   -17423.951   -17573.635   -17573.635     289.5747     289.5747    44090.596    44090.596    531.89671    531.89671 
   55000   -17418.162   -17418.162   -17569.535   -17569.535    292.84037    292.84037    44086.942    44086.942    939.68739    939.68739 
Loop time of 29.0093 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.978 ns/day, 8.058 hours/ns, 34.472 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.615     | 28.615     | 28.615     |   0.0 | 98.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06175    | 0.06175    | 0.06175    |   0.0 |  0.21
Output  | 6.6588e-05 | 6.6588e-05 | 6.6588e-05 |   0.0 |  0.00
Modify  | 0.29261    | 0.29261    | 0.29261    |   0.0 |  1.01
Other   |            | 0.03953    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704280.0 ave      704280 max      704280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704280
Ave neighs/atom = 176.07000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.799301247847, Press = 0.800938700232482
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -17418.162   -17418.162   -17569.535   -17569.535    292.84037    292.84037    44086.942    44086.942    939.68739    939.68739 
   56000   -17420.864   -17420.864   -17572.371   -17572.371    293.10149    293.10149    44095.232    44095.232    398.98128    398.98128 
Loop time of 28.9865 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.981 ns/day, 8.052 hours/ns, 34.499 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.593     | 28.593     | 28.593     |   0.0 | 98.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061768   | 0.061768   | 0.061768   |   0.0 |  0.21
Output  | 8.6469e-05 | 8.6469e-05 | 8.6469e-05 |   0.0 |  0.00
Modify  | 0.29221    | 0.29221    | 0.29221    |   0.0 |  1.01
Other   |            | 0.03967    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704420.0 ave      704420 max      704420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704420
Ave neighs/atom = 176.10500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.832853189949, Press = 0.387123652550228
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -17420.864   -17420.864   -17572.371   -17572.371    293.10149    293.10149    44095.232    44095.232    398.98128    398.98128 
   57000   -17416.586   -17416.586   -17569.664   -17569.664    296.13995    296.13995    44125.969    44125.969   -516.40519   -516.40519 
Loop time of 28.6933 on 1 procs for 1000 steps with 4000 atoms

Performance: 3.011 ns/day, 7.970 hours/ns, 34.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.308     | 28.308     | 28.308     |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060521   | 0.060521   | 0.060521   |   0.0 |  0.21
Output  | 7.0784e-05 | 7.0784e-05 | 7.0784e-05 |   0.0 |  0.00
Modify  | 0.28563    | 0.28563    | 0.28563    |   0.0 |  1.00
Other   |            | 0.03926    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704462.0 ave      704462 max      704462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704462
Ave neighs/atom = 176.11550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.877955393281, Press = -0.172556792048576
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -17416.586   -17416.586   -17569.664   -17569.664    296.13995    296.13995    44125.969    44125.969   -516.40519   -516.40519 
   58000   -17418.475   -17418.475   -17570.914   -17570.914    294.90287    294.90287    44155.209    44155.209   -1776.8892   -1776.8892 
Loop time of 29.2811 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.951 ns/day, 8.134 hours/ns, 34.152 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.88      | 28.88      | 28.88      |   0.0 | 98.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062378   | 0.062378   | 0.062378   |   0.0 |  0.21
Output  | 8.6996e-05 | 8.6996e-05 | 8.6996e-05 |   0.0 |  0.00
Modify  | 0.29825    | 0.29825    | 0.29825    |   0.0 |  1.02
Other   |            | 0.03996    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704152.0 ave      704152 max      704152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704152
Ave neighs/atom = 176.03800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.883364575628, Press = 0.237295655252732
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -17418.475   -17418.475   -17570.914   -17570.914    294.90287    294.90287    44155.209    44155.209   -1776.8892   -1776.8892 
   59000   -17424.792   -17424.792   -17573.004   -17573.004    286.72767    286.72767    44151.564    44151.564   -1883.2273   -1883.2273 
Loop time of 29.0428 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.975 ns/day, 8.067 hours/ns, 34.432 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.649     | 28.649     | 28.649     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061572   | 0.061572   | 0.061572   |   0.0 |  0.21
Output  | 6.6283e-05 | 6.6283e-05 | 6.6283e-05 |   0.0 |  0.00
Modify  | 0.2926     | 0.2926     | 0.2926     |   0.0 |  1.01
Other   |            | 0.03925    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      703976.0 ave      703976 max      703976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 703976
Ave neighs/atom = 175.99400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.881600622315, Press = 0.94281859277966
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -17424.792   -17424.792   -17573.004   -17573.004    286.72767    286.72767    44151.564    44151.564   -1883.2273   -1883.2273 
   60000   -17417.617   -17417.617   -17571.648   -17571.648    297.98491    297.98491    44136.905    44136.905   -1062.1517   -1062.1517 
Loop time of 29.2259 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.956 ns/day, 8.118 hours/ns, 34.216 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.828     | 28.828     | 28.828     |   0.0 | 98.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062168   | 0.062168   | 0.062168   |   0.0 |  0.21
Output  | 6.9107e-05 | 6.9107e-05 | 6.9107e-05 |   0.0 |  0.00
Modify  | 0.29646    | 0.29646    | 0.29646    |   0.0 |  1.01
Other   |            | 0.03966    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704010.0 ave      704010 max      704010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704010
Ave neighs/atom = 176.00250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.855735967466, Press = 1.23188282711809
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -17417.617   -17417.617   -17571.648   -17571.648    297.98491    297.98491    44136.905    44136.905   -1062.1517   -1062.1517 
   61000    -17421.95    -17421.95   -17572.376   -17572.376    291.00951    291.00951     44105.08     44105.08    63.809829    63.809829 
Loop time of 28.8435 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.995 ns/day, 8.012 hours/ns, 34.670 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.456     | 28.456     | 28.456     |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060877   | 0.060877   | 0.060877   |   0.0 |  0.21
Output  | 6.622e-05  | 6.622e-05  | 6.622e-05  |   0.0 |  0.00
Modify  | 0.28827    | 0.28827    | 0.28827    |   0.0 |  1.00
Other   |            | 0.03872    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704052.0 ave      704052 max      704052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704052
Ave neighs/atom = 176.01300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.855676331406, Press = 1.07823604112921
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000    -17421.95    -17421.95   -17572.376   -17572.376    291.00951    291.00951     44105.08     44105.08    63.809829    63.809829 
   62000   -17417.029   -17417.029   -17569.146   -17569.146    294.28087    294.28087    44104.057    44104.057    303.26023    303.26023 
Loop time of 28.7961 on 1 procs for 1000 steps with 4000 atoms

Performance: 3.000 ns/day, 7.999 hours/ns, 34.727 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.41      | 28.41      | 28.41      |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060599   | 0.060599   | 0.060599   |   0.0 |  0.21
Output  | 8.8386e-05 | 8.8386e-05 | 8.8386e-05 |   0.0 |  0.00
Modify  | 0.28686    | 0.28686    | 0.28686    |   0.0 |  1.00
Other   |            | 0.03829    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704280.0 ave      704280 max      704280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704280
Ave neighs/atom = 176.07000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.890227882927, Press = 0.645159783302024
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -17417.029   -17417.029   -17569.146   -17569.146    294.28087    294.28087    44104.057    44104.057    303.26023    303.26023 
   63000   -17418.304   -17418.304   -17571.729   -17571.729    296.81202    296.81202    44106.535    44106.535    50.042558    50.042558 
Loop time of 28.9497 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.984 ns/day, 8.042 hours/ns, 34.543 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.559     | 28.559     | 28.559     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061228   | 0.061228   | 0.061228   |   0.0 |  0.21
Output  | 6.5357e-05 | 6.5357e-05 | 6.5357e-05 |   0.0 |  0.00
Modify  | 0.29041    | 0.29041    | 0.29041    |   0.0 |  1.00
Other   |            | 0.03873    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704304.0 ave      704304 max      704304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704304
Ave neighs/atom = 176.07600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899523468565, Press = 0.424320341772993
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -17418.304   -17418.304   -17571.729   -17571.729    296.81202    296.81202    44106.535    44106.535    50.042558    50.042558 
   64000   -17422.441   -17422.441   -17571.189   -17571.189    287.76417    287.76417    44101.884    44101.884    203.35528    203.35528 
Loop time of 28.9007 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.990 ns/day, 8.028 hours/ns, 34.601 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.511     | 28.511     | 28.511     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061372   | 0.061372   | 0.061372   |   0.0 |  0.21
Output  | 6.803e-05  | 6.803e-05  | 6.803e-05  |   0.0 |  0.00
Modify  | 0.28949    | 0.28949    | 0.28949    |   0.0 |  1.00
Other   |            | 0.03903    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704332.0 ave      704332 max      704332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704332
Ave neighs/atom = 176.08300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.918498416852, Press = 0.368810988758496
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -17422.441   -17422.441   -17571.189   -17571.189    287.76417    287.76417    44101.884    44101.884    203.35528    203.35528 
   65000   -17420.927   -17420.927   -17571.927   -17571.927    292.11939    292.11939    44119.133    44119.133   -460.14101   -460.14101 
Loop time of 28.8866 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.991 ns/day, 8.024 hours/ns, 34.618 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.498     | 28.498     | 28.498     |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060918   | 0.060918   | 0.060918   |   0.0 |  0.21
Output  | 6.6741e-05 | 6.6741e-05 | 6.6741e-05 |   0.0 |  0.00
Modify  | 0.28863    | 0.28863    | 0.28863    |   0.0 |  1.00
Other   |            | 0.03854    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704384.0 ave      704384 max      704384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704384
Ave neighs/atom = 176.09600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.941980635689, Press = 0.43760853129985
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -17420.927   -17420.927   -17571.927   -17571.927    292.11939    292.11939    44119.133    44119.133   -460.14101   -460.14101 
   66000    -17422.43    -17422.43   -17574.037   -17574.037    293.29378    293.29378    44119.717    44119.717   -667.90401   -667.90401 
Loop time of 28.8731 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.992 ns/day, 8.020 hours/ns, 34.634 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.484     | 28.484     | 28.484     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061519   | 0.061519   | 0.061519   |   0.0 |  0.21
Output  | 8.9045e-05 | 8.9045e-05 | 8.9045e-05 |   0.0 |  0.00
Modify  | 0.28945    | 0.28945    | 0.28945    |   0.0 |  1.00
Other   |            | 0.03843    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704248.0 ave      704248 max      704248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704248
Ave neighs/atom = 176.06200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.962195242705, Press = 0.593625444697216
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000    -17422.43    -17422.43   -17574.037   -17574.037    293.29378    293.29378    44119.717    44119.717   -667.90401   -667.90401 
   67000   -17416.687   -17416.687   -17569.303   -17569.303    295.24599    295.24599    44123.849    44123.849   -483.63395   -483.63395 
Loop time of 28.9565 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.984 ns/day, 8.043 hours/ns, 34.535 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.566     | 28.566     | 28.566     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061619   | 0.061619   | 0.061619   |   0.0 |  0.21
Output  | 6.5683e-05 | 6.5683e-05 | 6.5683e-05 |   0.0 |  0.00
Modify  | 0.29026    | 0.29026    | 0.29026    |   0.0 |  1.00
Other   |            | 0.03871    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704332.0 ave      704332 max      704332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704332
Ave neighs/atom = 176.08300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.969048147909, Press = 0.864995076873556
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -17416.687   -17416.687   -17569.303   -17569.303    295.24599    295.24599    44123.849    44123.849   -483.63395   -483.63395 
   68000   -17419.254   -17419.254   -17571.504   -17571.504    294.53692    294.53692     44091.59     44091.59    565.64571    565.64571 
Loop time of 28.6522 on 1 procs for 1000 steps with 4000 atoms

Performance: 3.015 ns/day, 7.959 hours/ns, 34.901 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.27      | 28.27      | 28.27      |   0.0 | 98.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06048    | 0.06048    | 0.06048    |   0.0 |  0.21
Output  | 6.7446e-05 | 6.7446e-05 | 6.7446e-05 |   0.0 |  0.00
Modify  | 0.28347    | 0.28347    | 0.28347    |   0.0 |  0.99
Other   |            | 0.03775    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704196.0 ave      704196 max      704196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704196
Ave neighs/atom = 176.04900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.97249433539, Press = 1.28649730431383
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -17419.254   -17419.254   -17571.504   -17571.504    294.53692    294.53692     44091.59     44091.59    565.64571    565.64571 
   69000   -17419.064   -17419.064   -17570.445   -17570.445    292.85672    292.85672    44065.052    44065.052    1692.6364    1692.6364 
Loop time of 28.6834 on 1 procs for 1000 steps with 4000 atoms

Performance: 3.012 ns/day, 7.968 hours/ns, 34.863 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.299     | 28.299     | 28.299     |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060798   | 0.060798   | 0.060798   |   0.0 |  0.21
Output  | 6.6781e-05 | 6.6781e-05 | 6.6781e-05 |   0.0 |  0.00
Modify  | 0.28537    | 0.28537    | 0.28537    |   0.0 |  0.99
Other   |            | 0.03813    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704324.0 ave      704324 max      704324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704324
Ave neighs/atom = 176.08100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.008826316897, Press = 0.943058270238828
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -17419.064   -17419.064   -17570.445   -17570.445    292.85672    292.85672    44065.052    44065.052    1692.6364    1692.6364 
   70000   -17414.606   -17414.606   -17568.636   -17568.636    297.98003    297.98003    44065.068    44065.068    1896.7209    1896.7209 
Loop time of 28.8631 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.993 ns/day, 8.018 hours/ns, 34.646 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.474     | 28.474     | 28.474     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061149   | 0.061149   | 0.061149   |   0.0 |  0.21
Output  | 8.853e-05  | 8.853e-05  | 8.853e-05  |   0.0 |  0.00
Modify  | 0.28916    | 0.28916    | 0.28916    |   0.0 |  1.00
Other   |            | 0.03906    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704570.0 ave      704570 max      704570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704570
Ave neighs/atom = 176.14250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.022066360898, Press = 0.346873376243741
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -17414.606   -17414.606   -17568.636   -17568.636    297.98003    297.98003    44065.068    44065.068    1896.7209    1896.7209 
   71000   -17420.977   -17420.977   -17572.465   -17572.465    293.06455    293.06455    44068.859    44068.859     1400.219     1400.219 
Loop time of 28.8593 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.994 ns/day, 8.016 hours/ns, 34.651 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.47      | 28.47      | 28.47      |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061475   | 0.061475   | 0.061475   |   0.0 |  0.21
Output  | 6.7303e-05 | 6.7303e-05 | 6.7303e-05 |   0.0 |  0.00
Modify  | 0.28899    | 0.28899    | 0.28899    |   0.0 |  1.00
Other   |            | 0.03866    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704428.0 ave      704428 max      704428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704428
Ave neighs/atom = 176.10700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.045818174321, Press = -0.344122403104219
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -17420.977   -17420.977   -17572.465   -17572.465    293.06455    293.06455    44068.859    44068.859     1400.219     1400.219 
   72000   -17414.516   -17414.516   -17569.253   -17569.253    299.34926    299.34926    44125.317    44125.317   -436.92234   -436.92234 
Loop time of 28.8422 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.996 ns/day, 8.012 hours/ns, 34.671 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.454     | 28.454     | 28.454     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061333   | 0.061333   | 0.061333   |   0.0 |  0.21
Output  | 0.00010399 | 0.00010399 | 0.00010399 |   0.0 |  0.00
Modify  | 0.28812    | 0.28812    | 0.28812    |   0.0 |  1.00
Other   |            | 0.03869    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704434.0 ave      704434 max      704434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704434
Ave neighs/atom = 176.10850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.05333443612, Press = -0.894419980178541
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.709524
  ghost atom cutoff = 7.709524
  binsize = 3.854762, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.709524
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -17414.516   -17414.516   -17569.253   -17569.253    299.34926    299.34926    44125.317    44125.317   -436.92234   -436.92234 
   73000    -17420.57    -17420.57   -17572.312   -17572.312    293.55512    293.55512    44134.569    44134.569   -1071.4257   -1071.4257 
Loop time of 28.6402 on 1 procs for 1000 steps with 4000 atoms

Performance: 3.017 ns/day, 7.956 hours/ns, 34.916 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 28.258     | 28.258     | 28.258     |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060723   | 0.060723   | 0.060723   |   0.0 |  0.21
Output  | 7.068e-05  | 7.068e-05  | 7.068e-05  |   0.0 |  0.00
Modify  | 0.28378    | 0.28378    | 0.28378    |   0.0 |  0.99
Other   |            | 0.03807    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704204.0 ave      704204 max      704204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704204
Ave neighs/atom = 176.05100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
44108.4245759047

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0