# 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.165197603404522*${_u_distance}
variable latticeconst_converted equal 3.165197603404522*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.16519760340452
Lattice spacing in x,y,z = 3.1651976 3.1651976 3.1651976
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 (31.651976 31.651976 31.651976)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (31.651976 31.651976 31.651976)
  create_atoms CPU = 0.003 seconds

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

kim_interactions W

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

kim interactions W
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_MasonNguyenManhBecquart_2017_W__MO_268730733493_000
pair_coeff * * W
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 183.84

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31710.4558090515 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_268730733493_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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17719.089   -17719.089   -17800.004   -17800.004       313.15       313.15    31710.456    31710.456    2725.5226    2725.5226 
    1000   -17635.729   -17635.729   -17712.915   -17712.915    298.71775    298.71775    31811.121    31811.121    1543.9907    1543.9907 
Loop time of 11.2678 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.668 ns/day, 3.130 hours/ns, 88.749 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    | 10.665     | 10.665     | 10.665     |   0.0 | 94.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11753    | 0.11753    | 0.11753    |   0.0 |  1.04
Output  | 0.00019989 | 0.00019989 | 0.00019989 |   0.0 |  0.00
Modify  | 0.41954    | 0.41954    | 0.41954    |   0.0 |  3.72
Other   |            | 0.06564    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17635.729   -17635.729   -17712.915   -17712.915    298.71775    298.71775    31811.121    31811.121    1543.9907    1543.9907 
    2000   -17635.635   -17635.635   -17711.721   -17711.721    294.46222    294.46222    31854.353    31854.353    -1758.715    -1758.715 
Loop time of 10.9283 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.906 ns/day, 3.036 hours/ns, 91.505 timesteps/s
98.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    | 10.381     | 10.381     | 10.381     |   0.0 | 94.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1031     | 0.1031     | 0.1031     |   0.0 |  0.94
Output  | 0.00020621 | 0.00020621 | 0.00020621 |   0.0 |  0.00
Modify  | 0.37959    | 0.37959    | 0.37959    |   0.0 |  3.47
Other   |            | 0.0645     |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4029.00 ave        4029 max        4029 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:      126068.0 ave      126068 max      126068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126068
Ave neighs/atom = 63.034000
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17635.635   -17635.635   -17711.721   -17711.721    294.46222    294.46222    31854.353    31854.353    -1758.715    -1758.715 
    3000   -17637.452   -17637.452    -17721.08    -17721.08    323.64836    323.64836    31799.772    31799.772    1927.6364    1927.6364 
Loop time of 10.4693 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.253 ns/day, 2.908 hours/ns, 95.517 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    | 9.9607     | 9.9607     | 9.9607     |   0.0 | 95.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095705   | 0.095705   | 0.095705   |   0.0 |  0.91
Output  | 0.00026182 | 0.00026182 | 0.00026182 |   0.0 |  0.00
Modify  | 0.35261    | 0.35261    | 0.35261    |   0.0 |  3.37
Other   |            | 0.06008    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3996.00 ave        3996 max        3996 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:      125820.0 ave      125820 max      125820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125820
Ave neighs/atom = 62.910000
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17637.452   -17637.452    -17721.08    -17721.08    323.64836    323.64836    31799.772    31799.772    1927.6364    1927.6364 
    4000   -17634.435   -17634.435   -17717.355   -17717.355      320.908      320.908    31811.219    31811.219    1011.2352    1011.2352 
Loop time of 10.2312 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.445 ns/day, 2.842 hours/ns, 97.740 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    | 9.731      | 9.731      | 9.731      |   0.0 | 95.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093142   | 0.093142   | 0.093142   |   0.0 |  0.91
Output  | 0.00019375 | 0.00019375 | 0.00019375 |   0.0 |  0.00
Modify  | 0.34621    | 0.34621    | 0.34621    |   0.0 |  3.38
Other   |            | 0.06072    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4007.00 ave        4007 max        4007 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:      126318.0 ave      126318 max      126318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126318
Ave neighs/atom = 63.159000
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17634.435   -17634.435   -17717.355   -17717.355      320.908      320.908    31811.219    31811.219    1011.2352    1011.2352 
    5000   -17636.908   -17636.908   -17719.451   -17719.451    319.44896    319.44896    31847.079    31847.079   -2061.9544   -2061.9544 
Loop time of 10.1899 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.479 ns/day, 2.831 hours/ns, 98.136 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    | 9.6905     | 9.6905     | 9.6905     |   0.0 | 95.10
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093716   | 0.093716   | 0.093716   |   0.0 |  0.92
Output  | 0.00015305 | 0.00015305 | 0.00015305 |   0.0 |  0.00
Modify  | 0.34452    | 0.34452    | 0.34452    |   0.0 |  3.38
Other   |            | 0.06102    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3997.00 ave        3997 max        3997 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:      126042.0 ave      126042 max      126042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126042
Ave neighs/atom = 63.021000
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 = 313.575821602983, Press = 102.358839139705
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17636.908   -17636.908   -17719.451   -17719.451    319.44896    319.44896    31847.079    31847.079   -2061.9544   -2061.9544 
    6000   -17635.941   -17635.941   -17715.157   -17715.157     306.5735     306.5735    31848.774    31848.774   -1738.1909   -1738.1909 
Loop time of 10.1923 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.477 ns/day, 2.831 hours/ns, 98.113 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    | 9.6765     | 9.6765     | 9.6765     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094446   | 0.094446   | 0.094446   |   0.0 |  0.93
Output  | 0.00020447 | 0.00020447 | 0.00020447 |   0.0 |  0.00
Modify  | 0.36048    | 0.36048    | 0.36048    |   0.0 |  3.54
Other   |            | 0.06065    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4021.00 ave        4021 max        4021 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:      126046.0 ave      126046 max      126046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126046
Ave neighs/atom = 63.023000
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 = 312.004214708571, Press = 30.2447945937857
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17635.941   -17635.941   -17715.157   -17715.157     306.5735     306.5735    31848.774    31848.774   -1738.1909   -1738.1909 
    7000   -17639.966   -17639.966   -17717.551   -17717.551    300.26158    300.26158    31845.936    31845.936   -1721.6597   -1721.6597 
Loop time of 10.4389 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.277 ns/day, 2.900 hours/ns, 95.795 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    | 9.9113     | 9.9113     | 9.9113     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096406   | 0.096406   | 0.096406   |   0.0 |  0.92
Output  | 0.00019407 | 0.00019407 | 0.00019407 |   0.0 |  0.00
Modify  | 0.37       | 0.37       | 0.37       |   0.0 |  3.54
Other   |            | 0.06104    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3997.00 ave        3997 max        3997 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:      125978.0 ave      125978 max      125978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125978
Ave neighs/atom = 62.989000
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 = 312.401705810098, Press = 37.6378099950934
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17639.966   -17639.966   -17717.551   -17717.551    300.26158    300.26158    31845.936    31845.936   -1721.6597   -1721.6597 
    8000   -17635.227   -17635.227   -17716.838   -17716.838    315.84514    315.84514    31818.289    31818.289    951.72514    951.72514 
Loop time of 10.2789 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.406 ns/day, 2.855 hours/ns, 97.286 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    | 9.7633     | 9.7633     | 9.7633     |   0.0 | 94.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095254   | 0.095254   | 0.095254   |   0.0 |  0.93
Output  | 0.00019488 | 0.00019488 | 0.00019488 |   0.0 |  0.00
Modify  | 0.36005    | 0.36005    | 0.36005    |   0.0 |  3.50
Other   |            | 0.06013    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3997.00 ave        3997 max        3997 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:      126058.0 ave      126058 max      126058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126058
Ave neighs/atom = 63.029000
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 = 312.237389899838, Press = 26.6864962540294
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17635.227   -17635.227   -17716.838   -17716.838    315.84514    315.84514    31818.289    31818.289    951.72514    951.72514 
    9000   -17636.666   -17636.666   -17717.602   -17717.602    313.22946    313.22946    31820.459    31820.459    507.77544    507.77544 
Loop time of 10.4565 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.263 ns/day, 2.905 hours/ns, 95.634 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    | 9.9301     | 9.9301     | 9.9301     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095195   | 0.095195   | 0.095195   |   0.0 |  0.91
Output  | 0.00015333 | 0.00015333 | 0.00015333 |   0.0 |  0.00
Modify  | 0.37017    | 0.37017    | 0.37017    |   0.0 |  3.54
Other   |            | 0.06082    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3973.00 ave        3973 max        3973 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:      126188.0 ave      126188 max      126188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126188
Ave neighs/atom = 63.094000
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 = 312.407130118396, Press = 8.20930998814631
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17636.666   -17636.666   -17717.602   -17717.602    313.22946    313.22946    31820.459    31820.459    507.77544    507.77544 
   10000   -17634.841   -17634.841     -17716.4     -17716.4    315.64322    315.64322    31802.453    31802.453    2080.0668    2080.0668 
Loop time of 10.3061 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.383 ns/day, 2.863 hours/ns, 97.030 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    | 9.7862     | 9.7862     | 9.7862     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09421    | 0.09421    | 0.09421    |   0.0 |  0.91
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.36471    | 0.36471    | 0.36471    |   0.0 |  3.54
Other   |            | 0.06088    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4002.00 ave        4002 max        4002 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:      126104.0 ave      126104 max      126104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126104
Ave neighs/atom = 63.052000
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 = 312.92769061905, Press = -5.2115175141542
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17634.841   -17634.841     -17716.4     -17716.4    315.64322    315.64322    31802.453    31802.453    2080.0668    2080.0668 
   11000   -17636.659   -17636.659   -17716.006   -17716.006    307.07917    307.07917    31811.779    31811.779    1212.5618    1212.5618 
Loop time of 10.7195 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.060 ns/day, 2.978 hours/ns, 93.288 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    | 10.178     | 10.178     | 10.178     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097284   | 0.097284   | 0.097284   |   0.0 |  0.91
Output  | 0.00018964 | 0.00018964 | 0.00018964 |   0.0 |  0.00
Modify  | 0.38238    | 0.38238    | 0.38238    |   0.0 |  3.57
Other   |            | 0.06124    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4031.00 ave        4031 max        4031 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:      126112.0 ave      126112 max      126112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126112
Ave neighs/atom = 63.056000
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 = 312.805158123656, Press = 11.0867320881249
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17636.659   -17636.659   -17716.006   -17716.006    307.07917    307.07917    31811.779    31811.779    1212.5618    1212.5618 
   12000   -17633.716   -17633.716    -17717.14    -17717.14    322.85984    322.85984    31825.644    31825.644    467.36389    467.36389 
Loop time of 10.0007 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.639 ns/day, 2.778 hours/ns, 99.993 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    | 9.4974     | 9.4974     | 9.4974     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.090772   | 0.090772   | 0.090772   |   0.0 |  0.91
Output  | 0.00015506 | 0.00015506 | 0.00015506 |   0.0 |  0.00
Modify  | 0.35267    | 0.35267    | 0.35267    |   0.0 |  3.53
Other   |            | 0.05965    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4011.00 ave        4011 max        4011 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:      126090.0 ave      126090 max      126090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126090
Ave neighs/atom = 63.045000
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 = 312.957256139562, Press = 5.73223698716698
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17633.716   -17633.716    -17717.14    -17717.14    322.85984    322.85984    31825.644    31825.644    467.36389    467.36389 
   13000   -17637.652   -17637.652   -17718.758   -17718.758     313.8906     313.8906    31820.447    31820.447    250.81023    250.81023 
Loop time of 10.1901 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.479 ns/day, 2.831 hours/ns, 98.135 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    | 9.6768     | 9.6768     | 9.6768     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092175   | 0.092175   | 0.092175   |   0.0 |  0.90
Output  | 0.00015577 | 0.00015577 | 0.00015577 |   0.0 |  0.00
Modify  | 0.36075    | 0.36075    | 0.36075    |   0.0 |  3.54
Other   |            | 0.06022    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3983.00 ave        3983 max        3983 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:      126136.0 ave      126136 max      126136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126136
Ave neighs/atom = 63.068000
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 = 313.384850806282, Press = 8.54116850192968
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17637.652   -17637.652   -17718.758   -17718.758     313.8906     313.8906    31820.447    31820.447    250.81023    250.81023 
   14000   -17635.648   -17635.648   -17716.117   -17716.117    311.42362    311.42362    31819.313    31819.313    594.75188    594.75188 
Loop time of 10.2639 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.418 ns/day, 2.851 hours/ns, 97.429 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    | 9.7468     | 9.7468     | 9.7468     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094016   | 0.094016   | 0.094016   |   0.0 |  0.92
Output  | 0.00015522 | 0.00015522 | 0.00015522 |   0.0 |  0.00
Modify  | 0.3624     | 0.3624     | 0.3624     |   0.0 |  3.53
Other   |            | 0.06052    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4017.00 ave        4017 max        4017 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:      126216.0 ave      126216 max      126216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126216
Ave neighs/atom = 63.108000
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 = 313.351043890057, Press = 6.87739096720522
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17635.648   -17635.648   -17716.117   -17716.117    311.42362    311.42362    31819.313    31819.313    594.75188    594.75188 
   15000   -17637.716   -17637.716   -17717.866   -17717.866    310.18907    310.18907    31799.411    31799.411    2502.5989    2502.5989 
Loop time of 10.2839 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.401 ns/day, 2.857 hours/ns, 97.239 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    | 9.764      | 9.764      | 9.764      |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093968   | 0.093968   | 0.093968   |   0.0 |  0.91
Output  | 0.00015577 | 0.00015577 | 0.00015577 |   0.0 |  0.00
Modify  | 0.36499    | 0.36499    | 0.36499    |   0.0 |  3.55
Other   |            | 0.06081    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3996.00 ave        3996 max        3996 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:      126046.0 ave      126046 max      126046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126046
Ave neighs/atom = 63.023000
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 = 313.365940041879, Press = 3.63738072570665
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17637.716   -17637.716   -17717.866   -17717.866    310.18907    310.18907    31799.411    31799.411    2502.5989    2502.5989 
   16000   -17637.514   -17637.514   -17717.556   -17717.556    309.77203    309.77203    31833.165    31833.165   -454.59297   -454.59297 
Loop time of 10.1712 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.495 ns/day, 2.825 hours/ns, 98.317 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    | 9.6565     | 9.6565     | 9.6565     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093445   | 0.093445   | 0.093445   |   0.0 |  0.92
Output  | 0.00019924 | 0.00019924 | 0.00019924 |   0.0 |  0.00
Modify  | 0.35946    | 0.35946    | 0.35946    |   0.0 |  3.53
Other   |            | 0.06152    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4021.00 ave        4021 max        4021 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:      126172.0 ave      126172 max      126172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126172
Ave neighs/atom = 63.086000
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 = 313.279953968574, Press = 5.214639947311
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17637.514   -17637.514   -17717.556   -17717.556    309.77203    309.77203    31833.165    31833.165   -454.59297   -454.59297 
   17000   -17638.702   -17638.702   -17719.787   -17719.787    313.80942    313.80942    31850.415    31850.415   -2578.0739   -2578.0739 
Loop time of 10.7683 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.024 ns/day, 2.991 hours/ns, 92.866 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    | 10.224     | 10.224     | 10.224     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097887   | 0.097887   | 0.097887   |   0.0 |  0.91
Output  | 0.00015619 | 0.00015619 | 0.00015619 |   0.0 |  0.00
Modify  | 0.38415    | 0.38415    | 0.38415    |   0.0 |  3.57
Other   |            | 0.06239    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4020.00 ave        4020 max        4020 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:      126118.0 ave      126118 max      126118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126118
Ave neighs/atom = 63.059000
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 = 313.359956803094, Press = 9.52151489392842
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17638.702   -17638.702   -17719.787   -17719.787    313.80942    313.80942    31850.415    31850.415   -2578.0739   -2578.0739 
   18000   -17634.811   -17634.811     -17715.5     -17715.5    312.27475    312.27475    31818.262    31818.262    522.27623    522.27623 
Loop time of 10.0525 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.595 ns/day, 2.792 hours/ns, 99.478 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    | 9.5429     | 9.5429     | 9.5429     |   0.0 | 94.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092121   | 0.092121   | 0.092121   |   0.0 |  0.92
Output  | 0.00015474 | 0.00015474 | 0.00015474 |   0.0 |  0.00
Modify  | 0.35692    | 0.35692    | 0.35692    |   0.0 |  3.55
Other   |            | 0.06035    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3990.00 ave        3990 max        3990 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:      126124.0 ave      126124 max      126124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126124
Ave neighs/atom = 63.062000
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 = 313.187350278792, Press = 8.83010395924579
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17634.811   -17634.811     -17715.5     -17715.5    312.27475    312.27475    31818.262    31818.262    522.27623    522.27623 
   19000   -17637.639   -17637.639   -17718.152   -17718.152    311.59689    311.59689    31819.271    31819.271    624.92674    624.92674 
Loop time of 10.0104 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.631 ns/day, 2.781 hours/ns, 99.896 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    | 9.5039     | 9.5039     | 9.5039     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091777   | 0.091777   | 0.091777   |   0.0 |  0.92
Output  | 0.00014475 | 0.00014475 | 0.00014475 |   0.0 |  0.00
Modify  | 0.35444    | 0.35444    | 0.35444    |   0.0 |  3.54
Other   |            | 0.06014    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3993.00 ave        3993 max        3993 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:      126130.0 ave      126130 max      126130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126130
Ave neighs/atom = 63.065000
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 = 313.172226972554, Press = 5.13623514087508
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17637.639   -17637.639   -17718.152   -17718.152    311.59689    311.59689    31819.271    31819.271    624.92674    624.92674 
   20000   -17635.195   -17635.195   -17716.244   -17716.244    313.66719    313.66719     31792.36     31792.36    2689.6559    2689.6559 
Loop time of 10.1834 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.484 ns/day, 2.829 hours/ns, 98.199 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    | 9.6721     | 9.6721     | 9.6721     |   0.0 | 94.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093637   | 0.093637   | 0.093637   |   0.0 |  0.92
Output  | 0.00015889 | 0.00015889 | 0.00015889 |   0.0 |  0.00
Modify  | 0.35737    | 0.35737    | 0.35737    |   0.0 |  3.51
Other   |            | 0.06013    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4061.00 ave        4061 max        4061 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:      126044.0 ave      126044 max      126044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126044
Ave neighs/atom = 63.022000
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 = 313.352795985561, Press = 4.32325236295448
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17635.195   -17635.195   -17716.244   -17716.244    313.66719    313.66719     31792.36     31792.36    2689.6559    2689.6559 
   21000   -17638.119   -17638.119    -17717.09    -17717.09    305.62487    305.62487    31815.739    31815.739    1069.7786    1069.7786 
Loop time of 10.5721 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.172 ns/day, 2.937 hours/ns, 94.589 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    | 10.05      | 10.05      | 10.05      |   0.0 | 95.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096195   | 0.096195   | 0.096195   |   0.0 |  0.91
Output  | 0.00020215 | 0.00020215 | 0.00020215 |   0.0 |  0.00
Modify  | 0.36648    | 0.36648    | 0.36648    |   0.0 |  3.47
Other   |            | 0.05949    |            |       |  0.56

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4002.00 ave        4002 max        4002 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:      126138.0 ave      126138 max      126138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126138
Ave neighs/atom = 63.069000
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 = 313.271181603889, Press = 5.8036930711518
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17638.119   -17638.119    -17717.09    -17717.09    305.62487    305.62487    31815.739    31815.739    1069.7786    1069.7786 
   22000   -17638.699   -17638.699   -17716.244   -17716.244    300.10638    300.10638    31843.703    31843.703   -1427.0415   -1427.0415 
Loop time of 10.1914 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.478 ns/day, 2.831 hours/ns, 98.121 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    | 9.6807     | 9.6807     | 9.6807     |   0.0 | 94.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093627   | 0.093627   | 0.093627   |   0.0 |  0.92
Output  | 0.00015836 | 0.00015836 | 0.00015836 |   0.0 |  0.00
Modify  | 0.35687    | 0.35687    | 0.35687    |   0.0 |  3.50
Other   |            | 0.06011    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4034.00 ave        4034 max        4034 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:      126142.0 ave      126142 max      126142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126142
Ave neighs/atom = 63.071000
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 = 313.22977036706, Press = 4.67318241530899
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17638.699   -17638.699   -17716.244   -17716.244    300.10638    300.10638    31843.703    31843.703   -1427.0415   -1427.0415 
   23000   -17635.614   -17635.614   -17717.287   -17717.287    316.08287    316.08287    31834.856    31834.856   -751.06046   -751.06046 
Loop time of 10.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.022 ns/day, 2.992 hours/ns, 92.851 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    | 10.228     | 10.228     | 10.228     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097253   | 0.097253   | 0.097253   |   0.0 |  0.90
Output  | 0.00020316 | 0.00020316 | 0.00020316 |   0.0 |  0.00
Modify  | 0.38325    | 0.38325    | 0.38325    |   0.0 |  3.56
Other   |            | 0.0609     |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4014.00 ave        4014 max        4014 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:      126056.0 ave      126056 max      126056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126056
Ave neighs/atom = 63.028000
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 = 313.247550145978, Press = 3.73839490865638
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17635.614   -17635.614   -17717.287   -17717.287    316.08287    316.08287    31834.856    31834.856   -751.06046   -751.06046 
   24000   -17635.645   -17635.645   -17716.288   -17716.288    312.09665    312.09665    31817.687    31817.687    925.69037    925.69037 
Loop time of 10.1806 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.487 ns/day, 2.828 hours/ns, 98.226 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    | 9.6661     | 9.6661     | 9.6661     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093652   | 0.093652   | 0.093652   |   0.0 |  0.92
Output  | 0.00015625 | 0.00015625 | 0.00015625 |   0.0 |  0.00
Modify  | 0.36045    | 0.36045    | 0.36045    |   0.0 |  3.54
Other   |            | 0.06031    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4019.00 ave        4019 max        4019 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:      126014.0 ave      126014 max      126014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126014
Ave neighs/atom = 63.007000
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 = 313.139639326737, Press = 4.68174591144126
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17635.645   -17635.645   -17716.288   -17716.288    312.09665    312.09665    31817.687    31817.687    925.69037    925.69037 
   25000   -17636.648   -17636.648   -17717.959   -17717.959    314.68056    314.68056    31800.402    31800.402    2431.9616    2431.9616 
Loop time of 10.3476 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.350 ns/day, 2.874 hours/ns, 96.641 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    | 9.8251     | 9.8251     | 9.8251     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094282   | 0.094282   | 0.094282   |   0.0 |  0.91
Output  | 0.00015608 | 0.00015608 | 0.00015608 |   0.0 |  0.00
Modify  | 0.36771    | 0.36771    | 0.36771    |   0.0 |  3.55
Other   |            | 0.0603     |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4027.00 ave        4027 max        4027 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:      126080.0 ave      126080 max      126080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126080
Ave neighs/atom = 63.040000
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 = 313.093960606365, Press = 3.56295598202849
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17636.648   -17636.648   -17717.959   -17717.959    314.68056    314.68056    31800.402    31800.402    2431.9616    2431.9616 
   26000   -17637.209   -17637.209   -17717.938   -17717.938    312.42861    312.42861    31816.167    31816.167    827.92944    827.92944 
Loop time of 10.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.001 ns/day, 3.000 hours/ns, 92.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    | 10.256     | 10.256     | 10.256     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098555   | 0.098555   | 0.098555   |   0.0 |  0.91
Output  | 0.00015352 | 0.00015352 | 0.00015352 |   0.0 |  0.00
Modify  | 0.38315    | 0.38315    | 0.38315    |   0.0 |  3.55
Other   |            | 0.06134    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4020.00 ave        4020 max        4020 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:      126238.0 ave      126238 max      126238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126238
Ave neighs/atom = 63.119000
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 = 312.917842770769, Press = 2.88598280828064
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17637.209   -17637.209   -17717.938   -17717.938    312.42861    312.42861    31816.167    31816.167    827.92944    827.92944 
   27000   -17635.931   -17635.931   -17715.102   -17715.102    306.40057    306.40057    31810.592    31810.592    1676.4521    1676.4521 
Loop time of 10.2257 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.449 ns/day, 2.840 hours/ns, 97.793 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    | 9.711      | 9.711      | 9.711      |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094636   | 0.094636   | 0.094636   |   0.0 |  0.93
Output  | 0.00015636 | 0.00015636 | 0.00015636 |   0.0 |  0.00
Modify  | 0.35974    | 0.35974    | 0.35974    |   0.0 |  3.52
Other   |            | 0.06016    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4000.00 ave        4000 max        4000 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:      126150.0 ave      126150 max      126150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126150
Ave neighs/atom = 63.075000
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 = 312.943723844915, Press = 1.210814618064
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17635.931   -17635.931   -17715.102   -17715.102    306.40057    306.40057    31810.592    31810.592    1676.4521    1676.4521 
   28000   -17638.005   -17638.005   -17717.467   -17717.467    307.52565    307.52565     31829.43     31829.43   -263.49908   -263.49908 
Loop time of 10.7598 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.030 ns/day, 2.989 hours/ns, 92.939 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    | 10.211     | 10.211     | 10.211     |   0.0 | 94.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09817    | 0.09817    | 0.09817    |   0.0 |  0.91
Output  | 0.00015535 | 0.00015535 | 0.00015535 |   0.0 |  0.00
Modify  | 0.38797    | 0.38797    | 0.38797    |   0.0 |  3.61
Other   |            | 0.06246    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3971.00 ave        3971 max        3971 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:      126132.0 ave      126132 max      126132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126132
Ave neighs/atom = 63.066000
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 = 312.837462746617, Press = -0.245416153827072
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17638.005   -17638.005   -17717.467   -17717.467    307.52565    307.52565     31829.43     31829.43   -263.49908   -263.49908 
   29000   -17636.211   -17636.211   -17717.622   -17717.622    315.07194    315.07194    31843.533    31843.533   -1773.4666   -1773.4666 
Loop time of 10.0769 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.574 ns/day, 2.799 hours/ns, 99.237 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    | 9.5672     | 9.5672     | 9.5672     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092521   | 0.092521   | 0.092521   |   0.0 |  0.92
Output  | 0.00015542 | 0.00015542 | 0.00015542 |   0.0 |  0.00
Modify  | 0.35649    | 0.35649    | 0.35649    |   0.0 |  3.54
Other   |            | 0.06062    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3993.00 ave        3993 max        3993 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:      126102.0 ave      126102 max      126102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126102
Ave neighs/atom = 63.051000
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 = 312.905449983471, Press = 0.841681540982662
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17636.211   -17636.211   -17717.622   -17717.622    315.07194    315.07194    31843.533    31843.533   -1773.4666   -1773.4666 
   30000   -17638.973   -17638.973   -17717.834   -17717.834    305.20213    305.20213    31814.516    31814.516    947.39961    947.39961 
Loop time of 10.3922 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.314 ns/day, 2.887 hours/ns, 96.226 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    | 9.8662     | 9.8662     | 9.8662     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094144   | 0.094144   | 0.094144   |   0.0 |  0.91
Output  | 0.00016084 | 0.00016084 | 0.00016084 |   0.0 |  0.00
Modify  | 0.36989    | 0.36989    | 0.36989    |   0.0 |  3.56
Other   |            | 0.0618     |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3958.00 ave        3958 max        3958 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:      125994.0 ave      125994 max      125994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125994
Ave neighs/atom = 62.997000
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 = 312.904190081794, Press = 1.94238933406379
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17638.973   -17638.973   -17717.834   -17717.834    305.20213    305.20213    31814.516    31814.516    947.39961    947.39961 
   31000   -17635.502   -17635.502   -17716.129   -17716.129    312.03637    312.03637    31828.475    31828.475    116.87902    116.87902 
Loop time of 10.0755 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.575 ns/day, 2.799 hours/ns, 99.250 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    | 9.568      | 9.568      | 9.568      |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091729   | 0.091729   | 0.091729   |   0.0 |  0.91
Output  | 0.0001543  | 0.0001543  | 0.0001543  |   0.0 |  0.00
Modify  | 0.35543    | 0.35543    | 0.35543    |   0.0 |  3.53
Other   |            | 0.06025    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3990.00 ave        3990 max        3990 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:      126128.0 ave      126128 max      126128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126128
Ave neighs/atom = 63.064000
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 = 312.853643514308, Press = 2.50131065256
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17635.502   -17635.502   -17716.129   -17716.129    312.03637    312.03637    31828.475    31828.475    116.87902    116.87902 
   32000   -17638.617   -17638.617   -17718.037   -17718.037    307.36291    307.36291    31814.092    31814.092    537.45367    537.45367 
Loop time of 10.9773 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.871 ns/day, 3.049 hours/ns, 91.097 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    | 10.417     | 10.417     | 10.417     |   0.0 | 94.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099754   | 0.099754   | 0.099754   |   0.0 |  0.91
Output  | 0.00015302 | 0.00015302 | 0.00015302 |   0.0 |  0.00
Modify  | 0.39659    | 0.39659    | 0.39659    |   0.0 |  3.61
Other   |            | 0.06391    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3994.00 ave        3994 max        3994 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:      126050.0 ave      126050 max      126050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126050
Ave neighs/atom = 63.025000
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 = 312.826095069856, Press = 3.78536545445884
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17638.617   -17638.617   -17718.037   -17718.037    307.36291    307.36291    31814.092    31814.092    537.45367    537.45367 
   33000    -17635.22    -17635.22   -17716.569   -17716.569    314.82672    314.82672    31800.007    31800.007    2048.8735    2048.8735 
Loop time of 10.1231 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.535 ns/day, 2.812 hours/ns, 98.784 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    | 9.6111     | 9.6111     | 9.6111     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094298   | 0.094298   | 0.094298   |   0.0 |  0.93
Output  | 0.00019554 | 0.00019554 | 0.00019554 |   0.0 |  0.00
Modify  | 0.35663    | 0.35663    | 0.35663    |   0.0 |  3.52
Other   |            | 0.06092    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4011.00 ave        4011 max        4011 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:      126032.0 ave      126032 max      126032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126032
Ave neighs/atom = 63.016000
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 = 312.839612616585, Press = 3.08610889117996
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -17635.22    -17635.22   -17716.569   -17716.569    314.82672    314.82672    31800.007    31800.007    2048.8735    2048.8735 
   34000   -17638.545   -17638.545   -17718.006   -17718.006    307.52116    307.52116    31813.179    31813.179    1436.2796    1436.2796 
Loop time of 10.4847 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.241 ns/day, 2.912 hours/ns, 95.377 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    | 9.9506     | 9.9506     | 9.9506     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096361   | 0.096361   | 0.096361   |   0.0 |  0.92
Output  | 0.00015505 | 0.00015505 | 0.00015505 |   0.0 |  0.00
Modify  | 0.37548    | 0.37548    | 0.37548    |   0.0 |  3.58
Other   |            | 0.06212    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4043.00 ave        4043 max        4043 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:      126210.0 ave      126210 max      126210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126210
Ave neighs/atom = 63.105000
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 = 312.839738004019, Press = 2.71245947613486
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17638.545   -17638.545   -17718.006   -17718.006    307.52116    307.52116    31813.179    31813.179    1436.2796    1436.2796 
   35000   -17635.504   -17635.504   -17717.836   -17717.836    318.63638    318.63638    31826.974    31826.974   -155.08893   -155.08893 
Loop time of 11.5136 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.504 ns/day, 3.198 hours/ns, 86.854 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    | 10.926     | 10.926     | 10.926     |   0.0 | 94.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10634    | 0.10634    | 0.10634    |   0.0 |  0.92
Output  | 0.00015712 | 0.00015712 | 0.00015712 |   0.0 |  0.00
Modify  | 0.41604    | 0.41604    | 0.41604    |   0.0 |  3.61
Other   |            | 0.06456    |            |       |  0.56

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4038.00 ave        4038 max        4038 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:      126160.0 ave      126160 max      126160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126160
Ave neighs/atom = 63.080000
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 = 312.776887088937, Press = 2.05972660964419
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17635.504   -17635.504   -17717.836   -17717.836    318.63638    318.63638    31826.974    31826.974   -155.08893   -155.08893 
   36000   -17637.899   -17637.899   -17719.034   -17719.034    314.00065    314.00065     31806.45     31806.45    1692.2263    1692.2263 
Loop time of 10.4555 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.264 ns/day, 2.904 hours/ns, 95.644 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    | 9.9164     | 9.9164     | 9.9164     |   0.0 | 94.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09786    | 0.09786    | 0.09786    |   0.0 |  0.94
Output  | 0.00015349 | 0.00015349 | 0.00015349 |   0.0 |  0.00
Modify  | 0.37918    | 0.37918    | 0.37918    |   0.0 |  3.63
Other   |            | 0.06192    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4020.00 ave        4020 max        4020 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:      126112.0 ave      126112 max      126112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126112
Ave neighs/atom = 63.056000
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 = 312.788351768015, Press = 4.09747921099519
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17637.899   -17637.899   -17719.034   -17719.034    314.00065    314.00065     31806.45     31806.45    1692.2263    1692.2263 
   37000   -17635.581   -17635.581   -17716.648   -17716.648    313.73501    313.73501    31802.107    31802.107    2217.2252    2217.2252 
Loop time of 10.9794 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.869 ns/day, 3.050 hours/ns, 91.079 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    | 10.42      | 10.42      | 10.42      |   0.0 | 94.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10195    | 0.10195    | 0.10195    |   0.0 |  0.93
Output  | 0.00019933 | 0.00019933 | 0.00019933 |   0.0 |  0.00
Modify  | 0.39439    | 0.39439    | 0.39439    |   0.0 |  3.59
Other   |            | 0.06292    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4027.00 ave        4027 max        4027 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:      126182.0 ave      126182 max      126182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126182
Ave neighs/atom = 63.091000
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 = 312.870793272912, Press = 2.53059076217394
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17635.581   -17635.581   -17716.648   -17716.648    313.73501    313.73501    31802.107    31802.107    2217.2252    2217.2252 
   38000   -17633.148   -17633.148   -17715.788   -17715.788    319.82249    319.82249    31831.483    31831.483   -349.45706   -349.45706 
Loop time of 10.3184 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.373 ns/day, 2.866 hours/ns, 96.914 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    | 9.8035     | 9.8035     | 9.8035     |   0.0 | 95.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094907   | 0.094907   | 0.094907   |   0.0 |  0.92
Output  | 0.00020016 | 0.00020016 | 0.00020016 |   0.0 |  0.00
Modify  | 0.36003    | 0.36003    | 0.36003    |   0.0 |  3.49
Other   |            | 0.05977    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4001.00 ave        4001 max        4001 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:      126130.0 ave      126130 max      126130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126130
Ave neighs/atom = 63.065000
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 = 312.922351387951, Press = 2.19491563357762
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17633.148   -17633.148   -17715.788   -17715.788    319.82249    319.82249    31831.483    31831.483   -349.45706   -349.45706 
   39000    -17636.15    -17636.15   -17717.617   -17717.617     315.2867     315.2867    31798.685    31798.685     2446.331     2446.331 
Loop time of 10.1609 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.503 ns/day, 2.822 hours/ns, 98.417 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    | 9.647      | 9.647      | 9.647      |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093029   | 0.093029   | 0.093029   |   0.0 |  0.92
Output  | 0.00015355 | 0.00015355 | 0.00015355 |   0.0 |  0.00
Modify  | 0.35976    | 0.35976    | 0.35976    |   0.0 |  3.54
Other   |            | 0.06093    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4009.00 ave        4009 max        4009 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:      126014.0 ave      126014 max      126014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126014
Ave neighs/atom = 63.007000
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 = 312.921770442506, Press = 1.60712989388577
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 = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -17636.15    -17636.15   -17717.617   -17717.617     315.2867     315.2867    31798.685    31798.685     2446.331     2446.331 
   40000   -17629.428   -17629.428   -17713.412   -17713.412    325.03028    325.03028    31813.998    31813.998    1424.2375    1424.2375 
Loop time of 10.0236 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.620 ns/day, 2.784 hours/ns, 99.765 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    | 9.5159     | 9.5159     | 9.5159     |   0.0 | 94.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09143    | 0.09143    | 0.09143    |   0.0 |  0.91
Output  | 0.00015335 | 0.00015335 | 0.00015335 |   0.0 |  0.00
Modify  | 0.35618    | 0.35618    | 0.35618    |   0.0 |  3.55
Other   |            | 0.05995    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4004.00 ave        4004 max        4004 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:      126144.0 ave      126144 max      126144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126144
Ave neighs/atom = 63.072000
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
31826.2181587911

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0