# 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 4.068500626087188*${_u_distance}
variable latticeconst_converted equal 4.068500626087188*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.06850062608719
Lattice spacing in x,y,z = 4.0685006 4.0685006 4.0685006
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 (40.685006 40.685006 40.685006)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.685006 40.685006 40.685006)
  create_atoms CPU = 0.006 seconds

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

kim_interactions Au

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

kim interactions Au
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_NormanStarikovStegailov_2012_Au__MO_592431957881_000
pair_coeff * * Au
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 196.96655

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 67344.6595094155 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_592431957881_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17025.242   -17025.242   -17197.451   -17197.451       333.15       333.15     67344.66     67344.66    2731.3514    2731.3514 
    1000   -16822.479   -16822.479   -17006.717   -17006.717    356.42012    356.42012    68396.513    68396.513   -1640.2636   -1640.2636 
Loop time of 38.4601 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.246 ns/day, 10.683 hours/ns, 26.001 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    | 37.45      | 37.45      | 37.45      |   0.0 | 97.37
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15829    | 0.15829    | 0.15829    |   0.0 |  0.41
Output  | 0.00023254 | 0.00023254 | 0.00023254 |   0.0 |  0.00
Modify  | 0.7466     | 0.7466     | 0.7466     |   0.0 |  1.94
Other   |            | 0.1049     |            |       |  0.27

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      344000.0 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86.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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -16822.479   -16822.479   -17006.717   -17006.717    356.42012    356.42012    68396.513    68396.513   -1640.2636   -1640.2636 
    2000   -16846.138   -16846.138   -17011.991   -17011.991    320.85246    320.85246    68302.973    68302.973   -241.50128   -241.50128 
Loop time of 43.6912 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.978 ns/day, 12.136 hours/ns, 22.888 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    | 42.594     | 42.594     | 42.594     |   0.0 | 97.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16548    | 0.16548    | 0.16548    |   0.0 |  0.38
Output  | 0.00027723 | 0.00027723 | 0.00027723 |   0.0 |  0.00
Modify  | 0.82311    | 0.82311    | 0.82311    |   0.0 |  1.88
Other   |            | 0.1087     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410334.0 ave      410334 max      410334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410334
Ave neighs/atom = 102.58350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -16846.138   -16846.138   -17011.991   -17011.991    320.85246    320.85246    68302.973    68302.973   -241.50128   -241.50128 
    3000   -16839.602   -16839.602   -17016.126   -17016.126    341.49669    341.49669    68286.355    68286.355   -88.891123   -88.891123 
Loop time of 43.5003 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.986 ns/day, 12.083 hours/ns, 22.988 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    | 42.441     | 42.441     | 42.441     |   0.0 | 97.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16819    | 0.16819    | 0.16819    |   0.0 |  0.39
Output  | 0.00021688 | 0.00021688 | 0.00021688 |   0.0 |  0.00
Modify  | 0.78481    | 0.78481    | 0.78481    |   0.0 |  1.80
Other   |            | 0.1063     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411232.0 ave      411232 max      411232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411232
Ave neighs/atom = 102.80800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -16839.602   -16839.602   -17016.126   -17016.126    341.49669    341.49669    68286.355    68286.355   -88.891123   -88.891123 
    4000   -16838.483   -16838.483   -17012.747   -17012.747    337.12596    337.12596    68309.789    68309.789   -326.93069   -326.93069 
Loop time of 41.1535 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.099 ns/day, 11.432 hours/ns, 24.299 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    | 40.167     | 40.167     | 40.167     |   0.0 | 97.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15358    | 0.15358    | 0.15358    |   0.0 |  0.37
Output  | 0.00021682 | 0.00021682 | 0.00021682 |   0.0 |  0.00
Modify  | 0.72875    | 0.72875    | 0.72875    |   0.0 |  1.77
Other   |            | 0.1036     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410742.0 ave      410742 max      410742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410742
Ave neighs/atom = 102.68550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -16838.483   -16838.483   -17012.747   -17012.747    337.12596    337.12596    68309.789    68309.789   -326.93069   -326.93069 
    5000   -16838.594   -16838.594   -17011.224   -17011.224    333.96544    333.96544    68334.583    68334.583   -662.80535   -662.80535 
Loop time of 38.1232 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.266 ns/day, 10.590 hours/ns, 26.231 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    | 37.244     | 37.244     | 37.244     |   0.0 | 97.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13903    | 0.13903    | 0.13903    |   0.0 |  0.36
Output  | 0.00017536 | 0.00017536 | 0.00017536 |   0.0 |  0.00
Modify  | 0.64104    | 0.64104    | 0.64104    |   0.0 |  1.68
Other   |            | 0.09885    |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410828.0 ave      410828 max      410828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410828
Ave neighs/atom = 102.70700
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 = 332.431898727953, Press = 197.964382355073
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -16838.594   -16838.594   -17011.224   -17011.224    333.96544    333.96544    68334.583    68334.583   -662.80535   -662.80535 
    6000   -16842.277   -16842.277    -17013.83    -17013.83    331.88154    331.88154    68275.645    68275.645    467.44998    467.44998 
Loop time of 38.2569 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.258 ns/day, 10.627 hours/ns, 26.139 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    | 37.352     | 37.352     | 37.352     |   0.0 | 97.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13974    | 0.13974    | 0.13974    |   0.0 |  0.37
Output  | 0.00022274 | 0.00022274 | 0.00022274 |   0.0 |  0.00
Modify  | 0.66583    | 0.66583    | 0.66583    |   0.0 |  1.74
Other   |            | 0.09925    |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410708.0 ave      410708 max      410708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410708
Ave neighs/atom = 102.67700
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 = 333.17728058262, Press = 1.67948753719488
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -16842.277   -16842.277    -17013.83    -17013.83    331.88154    331.88154    68275.645    68275.645    467.44998    467.44998 
    7000   -16836.746   -16836.746   -17010.669   -17010.669    336.46532    336.46532    68254.393    68254.393    1467.8532    1467.8532 
Loop time of 38.1816 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.263 ns/day, 10.606 hours/ns, 26.191 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.278     | 37.278     | 37.278     |   0.0 | 97.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13913    | 0.13913    | 0.13913    |   0.0 |  0.36
Output  | 0.0001781  | 0.0001781  | 0.0001781  |   0.0 |  0.00
Modify  | 0.66428    | 0.66428    | 0.66428    |   0.0 |  1.74
Other   |            | 0.09987    |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411452.0 ave      411452 max      411452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411452
Ave neighs/atom = 102.86300
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 = 333.041384582397, Press = 9.9456913069931
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -16836.746   -16836.746   -17010.669   -17010.669    336.46532    336.46532    68254.393    68254.393    1467.8532    1467.8532 
    8000   -16843.168   -16843.168   -17015.764   -17015.764    333.89899    333.89899    68302.313    68302.313   -526.43587   -526.43587 
Loop time of 38.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.261 ns/day, 10.614 hours/ns, 26.170 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.308     | 37.308     | 37.308     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13928    | 0.13928    | 0.13928    |   0.0 |  0.36
Output  | 0.00017626 | 0.00017626 | 0.00017626 |   0.0 |  0.00
Modify  | 0.66404    | 0.66404    | 0.66404    |   0.0 |  1.74
Other   |            | 0.09981    |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411988.0 ave      411988 max      411988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411988
Ave neighs/atom = 102.99700
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 = 333.133838234073, Press = 4.03074541013963
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -16843.168   -16843.168   -17015.764   -17015.764    333.89899    333.89899    68302.313    68302.313   -526.43587   -526.43587 
    9000   -16843.032   -16843.032    -17013.21    -17013.21    329.22121    329.22121    68227.927    68227.927     1841.418     1841.418 
Loop time of 38.1906 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.262 ns/day, 10.608 hours/ns, 26.184 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.288     | 37.288     | 37.288     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13981    | 0.13981    | 0.13981    |   0.0 |  0.37
Output  | 0.00017851 | 0.00017851 | 0.00017851 |   0.0 |  0.00
Modify  | 0.66381    | 0.66381    | 0.66381    |   0.0 |  1.74
Other   |            | 0.09904    |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410774.0 ave      410774 max      410774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410774
Ave neighs/atom = 102.69350
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 = 333.159819374156, Press = 18.3259185384084
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -16843.032   -16843.032    -17013.21    -17013.21    329.22121    329.22121    68227.927    68227.927     1841.418     1841.418 
   10000   -16840.157   -16840.157   -17012.327   -17012.327     333.0744     333.0744    68302.521    68302.521   -66.509678   -66.509678 
Loop time of 38.2571 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.258 ns/day, 10.627 hours/ns, 26.139 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.354     | 37.354     | 37.354     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13893    | 0.13893    | 0.13893    |   0.0 |  0.36
Output  | 0.0001781  | 0.0001781  | 0.0001781  |   0.0 |  0.00
Modify  | 0.66413    | 0.66413    | 0.66413    |   0.0 |  1.74
Other   |            | 0.09944    |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      412580.0 ave      412580 max      412580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 412580
Ave neighs/atom = 103.14500
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 = 332.850511384842, Press = 11.1249215487708
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -16840.157   -16840.157   -17012.327   -17012.327     333.0744     333.0744    68302.521    68302.521   -66.509678   -66.509678 
   11000   -16841.472   -16841.472   -17015.468   -17015.468    336.60786    336.60786     68218.33     68218.33     1636.635     1636.635 
Loop time of 38.8159 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.226 ns/day, 10.782 hours/ns, 25.763 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    | 37.903     | 37.903     | 37.903     |   0.0 | 97.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14403    | 0.14403    | 0.14403    |   0.0 |  0.37
Output  | 0.00018179 | 0.00018179 | 0.00018179 |   0.0 |  0.00
Modify  | 0.67175    | 0.67175    | 0.67175    |   0.0 |  1.73
Other   |            | 0.09696    |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411408.0 ave      411408 max      411408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411408
Ave neighs/atom = 102.85200
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 = 332.8559142634, Press = 10.7597695888835
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -16841.472   -16841.472   -17015.468   -17015.468    336.60786    336.60786     68218.33     68218.33     1636.635     1636.635 
   12000   -16840.465   -16840.465   -17011.054   -17011.054    330.01595    330.01595    68267.846    68267.846     895.9029     895.9029 
Loop time of 40.372 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.140 ns/day, 11.214 hours/ns, 24.770 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 39.406     | 39.406     | 39.406     |   0.0 | 97.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15292    | 0.15292    | 0.15292    |   0.0 |  0.38
Output  | 0.00018435 | 0.00018435 | 0.00018435 |   0.0 |  0.00
Modify  | 0.7156     | 0.7156     | 0.7156     |   0.0 |  1.77
Other   |            | 0.09734    |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      412774.0 ave      412774 max      412774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 412774
Ave neighs/atom = 103.19350
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 = 332.876641575273, Press = 8.52153629687985
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -16840.465   -16840.465   -17011.054   -17011.054    330.01595    330.01595    68267.846    68267.846     895.9029     895.9029 
   13000   -16841.835   -16841.835   -17010.918   -17010.918    327.10199    327.10199    68299.965    68299.965    18.280316    18.280316 
Loop time of 43.754 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.975 ns/day, 12.154 hours/ns, 22.855 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    | 42.634     | 42.634     | 42.634     |   0.0 | 97.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16578    | 0.16578    | 0.16578    |   0.0 |  0.38
Output  | 0.00017889 | 0.00017889 | 0.00017889 |   0.0 |  0.00
Modify  | 0.84578    | 0.84578    | 0.84578    |   0.0 |  1.93
Other   |            | 0.1078     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411990.0 ave      411990 max      411990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411990
Ave neighs/atom = 102.99750
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 = 332.882571928061, Press = 0.815336465699282
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -16841.835   -16841.835   -17010.918   -17010.918    327.10199    327.10199    68299.965    68299.965    18.280316    18.280316 
   14000   -16846.536   -16846.536   -17015.854   -17015.854     327.5571     327.5571    68238.223    68238.223    1059.7819    1059.7819 
Loop time of 43.6957 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.977 ns/day, 12.138 hours/ns, 22.886 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    | 42.576     | 42.576     | 42.576     |   0.0 | 97.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1661     | 0.1661     | 0.1661     |   0.0 |  0.38
Output  | 0.00023918 | 0.00023918 | 0.00023918 |   0.0 |  0.00
Modify  | 0.8452     | 0.8452     | 0.8452     |   0.0 |  1.93
Other   |            | 0.1083     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411126.0 ave      411126 max      411126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411126
Ave neighs/atom = 102.78150
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 = 332.744324109364, Press = 2.8138014224397
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -16846.536   -16846.536   -17015.854   -17015.854     327.5571     327.5571    68238.223    68238.223    1059.7819    1059.7819 
   15000   -16833.452   -16833.452   -17007.198   -17007.198    336.12381    336.12381    68316.461    68316.461    158.01913    158.01913 
Loop time of 44.4815 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.942 ns/day, 12.356 hours/ns, 22.481 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 43.332     | 43.332     | 43.332     |   0.0 | 97.42
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17069    | 0.17069    | 0.17069    |   0.0 |  0.38
Output  | 0.00057274 | 0.00057274 | 0.00057274 |   0.0 |  0.00
Modify  | 0.86851    | 0.86851    | 0.86851    |   0.0 |  1.95
Other   |            | 0.1096     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411880.0 ave      411880 max      411880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411880
Ave neighs/atom = 102.97000
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 = 332.783978752896, Press = 2.93205054229436
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -16833.452   -16833.452   -17007.198   -17007.198    336.12381    336.12381    68316.461    68316.461    158.01913    158.01913 
   16000   -16840.389   -16840.389   -17013.053   -17013.053    334.03022    334.03022     68293.19     68293.19    38.203552    38.203552 
Loop time of 40.7642 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.120 ns/day, 11.323 hours/ns, 24.531 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    | 39.768     | 39.768     | 39.768     |   0.0 | 97.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1543     | 0.1543     | 0.1543     |   0.0 |  0.38
Output  | 0.00018225 | 0.00018225 | 0.00018225 |   0.0 |  0.00
Modify  | 0.74087    | 0.74087    | 0.74087    |   0.0 |  1.82
Other   |            | 0.1009     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411434.0 ave      411434 max      411434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411434
Ave neighs/atom = 102.85850
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 = 332.934995909778, Press = 2.4943785940314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -16840.389   -16840.389   -17013.053   -17013.053    334.03022    334.03022     68293.19     68293.19    38.203552    38.203552 
   17000   -16842.214   -16842.214   -17018.889   -17018.889    341.78951    341.78951    68284.895    68284.895   -497.89961   -497.89961 
Loop time of 38.8198 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.226 ns/day, 10.783 hours/ns, 25.760 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.906     | 37.906     | 37.906     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14526    | 0.14526    | 0.14526    |   0.0 |  0.37
Output  | 0.00018148 | 0.00018148 | 0.00018148 |   0.0 |  0.00
Modify  | 0.6728     | 0.6728     | 0.6728     |   0.0 |  1.73
Other   |            | 0.09597    |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411364.0 ave      411364 max      411364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411364
Ave neighs/atom = 102.84100
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 = 332.904561506429, Press = -4.08444101771181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -16842.214   -16842.214   -17018.889   -17018.889    341.78951    341.78951    68284.895    68284.895   -497.89961   -497.89961 
   18000   -16840.772   -16840.772   -17009.818   -17009.818    327.03112    327.03112    68316.659    68316.659   -221.09079   -221.09079 
Loop time of 38.7721 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.228 ns/day, 10.770 hours/ns, 25.792 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    | 37.855     | 37.855     | 37.855     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14841    | 0.14841    | 0.14841    |   0.0 |  0.38
Output  | 0.00018157 | 0.00018157 | 0.00018157 |   0.0 |  0.00
Modify  | 0.67298    | 0.67298    | 0.67298    |   0.0 |  1.74
Other   |            | 0.09516    |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410768.0 ave      410768 max      410768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410768
Ave neighs/atom = 102.69200
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 = 332.764650451855, Press = 0.333831226344885
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -16840.772   -16840.772   -17009.818   -17009.818    327.03112    327.03112    68316.659    68316.659   -221.09079   -221.09079 
   19000   -16838.069   -16838.069   -17012.998   -17012.998     338.4107     338.4107    68216.036    68216.036    2094.3136    2094.3136 
Loop time of 38.7703 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.229 ns/day, 10.770 hours/ns, 25.793 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    | 37.857     | 37.857     | 37.857     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14526    | 0.14526    | 0.14526    |   0.0 |  0.37
Output  | 0.00018058 | 0.00018058 | 0.00018058 |   0.0 |  0.00
Modify  | 0.67184    | 0.67184    | 0.67184    |   0.0 |  1.73
Other   |            | 0.09612    |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410688.0 ave      410688 max      410688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410688
Ave neighs/atom = 102.67200
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 = 332.852662541075, Press = 4.90103950213012
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -16838.069   -16838.069   -17012.998   -17012.998     338.4107     338.4107    68216.036    68216.036    2094.3136    2094.3136 
   20000   -16839.735   -16839.735   -17011.801   -17011.801    332.87287    332.87287    68285.192    68285.192    388.52204    388.52204 
Loop time of 42.6433 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.026 ns/day, 11.845 hours/ns, 23.450 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    | 41.566     | 41.566     | 41.566     |   0.0 | 97.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16181    | 0.16181    | 0.16181    |   0.0 |  0.38
Output  | 0.00017823 | 0.00017823 | 0.00017823 |   0.0 |  0.00
Modify  | 0.80763    | 0.80763    | 0.80763    |   0.0 |  1.89
Other   |            | 0.1072     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      412976.0 ave      412976 max      412976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 412976
Ave neighs/atom = 103.24400
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 = 332.904282782092, Press = 3.17890754719938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -16839.735   -16839.735   -17011.801   -17011.801    332.87287    332.87287    68285.192    68285.192    388.52204    388.52204 
   21000   -16836.809   -16836.809   -17011.291   -17011.291    337.54694    337.54694    68254.497    68254.497    1273.4933    1273.4933 
Loop time of 38.4816 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.245 ns/day, 10.689 hours/ns, 25.986 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    | 37.568     | 37.568     | 37.568     |   0.0 | 97.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14048    | 0.14048    | 0.14048    |   0.0 |  0.37
Output  | 0.00017886 | 0.00017886 | 0.00017886 |   0.0 |  0.00
Modify  | 0.67214    | 0.67214    | 0.67214    |   0.0 |  1.75
Other   |            | 0.1006     |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411768.0 ave      411768 max      411768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411768
Ave neighs/atom = 102.94200
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 = 332.929354833202, Press = 2.14334774226552
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -16836.809   -16836.809   -17011.291   -17011.291    337.54694    337.54694    68254.497    68254.497    1273.4933    1273.4933 
   22000    -16844.52    -16844.52   -17014.411   -17014.411     328.6643     328.6643    68242.939    68242.939    1068.3423    1068.3423 
Loop time of 38.1516 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.265 ns/day, 10.598 hours/ns, 26.211 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    | 37.251     | 37.251     | 37.251     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1394     | 0.1394     | 0.1394     |   0.0 |  0.37
Output  | 0.00017714 | 0.00017714 | 0.00017714 |   0.0 |  0.00
Modify  | 0.66143    | 0.66143    | 0.66143    |   0.0 |  1.73
Other   |            | 0.09999    |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      412398.0 ave      412398 max      412398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 412398
Ave neighs/atom = 103.09950
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 = 332.911510276185, Press = 1.89067696387383
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -16844.52    -16844.52   -17014.411   -17014.411     328.6643     328.6643    68242.939    68242.939    1068.3423    1068.3423 
   23000   -16844.249   -16844.249    -17012.94    -17012.94    326.34399    326.34399    68238.517    68238.517     1369.745     1369.745 
Loop time of 38.1899 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.262 ns/day, 10.608 hours/ns, 26.185 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    | 37.289     | 37.289     | 37.289     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13885    | 0.13885    | 0.13885    |   0.0 |  0.36
Output  | 0.00017696 | 0.00017696 | 0.00017696 |   0.0 |  0.00
Modify  | 0.66174    | 0.66174    | 0.66174    |   0.0 |  1.73
Other   |            | 0.1        |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      412072.0 ave      412072 max      412072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 412072
Ave neighs/atom = 103.01800
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 = 332.908485348235, Press = 3.05531487987696
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -16844.249   -16844.249    -17012.94    -17012.94    326.34399    326.34399    68238.517    68238.517     1369.745     1369.745 
   24000   -16837.531   -16837.531   -17011.674   -17011.674    336.89051    336.89051     68353.95     68353.95   -1313.7943   -1313.7943 
Loop time of 38.2011 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.262 ns/day, 10.611 hours/ns, 26.177 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.301     | 37.301     | 37.301     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13853    | 0.13853    | 0.13853    |   0.0 |  0.36
Output  | 0.00017767 | 0.00017767 | 0.00017767 |   0.0 |  0.00
Modify  | 0.66197    | 0.66197    | 0.66197    |   0.0 |  1.73
Other   |            | 0.09956    |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      412836.0 ave      412836 max      412836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 412836
Ave neighs/atom = 103.20900
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 = 332.838349573489, Press = 0.909794825937072
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -16837.531   -16837.531   -17011.674   -17011.674    336.89051    336.89051     68353.95     68353.95   -1313.7943   -1313.7943 
   25000   -16837.009   -16837.009   -17009.338   -17009.338    333.38295    333.38295    68389.581    68389.581   -2004.4038   -2004.4038 
Loop time of 39.3963 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.193 ns/day, 10.943 hours/ns, 25.383 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    | 38.451     | 38.451     | 38.451     |   0.0 | 97.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14484    | 0.14484    | 0.14484    |   0.0 |  0.37
Output  | 0.00018169 | 0.00018169 | 0.00018169 |   0.0 |  0.00
Modify  | 0.69851    | 0.69851    | 0.69851    |   0.0 |  1.77
Other   |            | 0.1014     |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410300.0 ave      410300 max      410300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410300
Ave neighs/atom = 102.57500
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 = 332.849670970454, Press = 0.274830683040871
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -16837.009   -16837.009   -17009.338   -17009.338    333.38295    333.38295    68389.581    68389.581   -2004.4038   -2004.4038 
   26000   -16846.151   -16846.151   -17015.158   -17015.158    326.95645    326.95645    68257.308    68257.308    702.10352    702.10352 
Loop time of 44.5611 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.939 ns/day, 12.378 hours/ns, 22.441 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    | 43.429     | 43.429     | 43.429     |   0.0 | 97.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1711     | 0.1711     | 0.1711     |   0.0 |  0.38
Output  | 0.00022362 | 0.00022362 | 0.00022362 |   0.0 |  0.00
Modify  | 0.85458    | 0.85458    | 0.85458    |   0.0 |  1.92
Other   |            | 0.1061     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      409202.0 ave      409202 max      409202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 409202
Ave neighs/atom = 102.30050
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 = 332.845428798859, Press = -0.229377952250867
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -16846.151   -16846.151   -17015.158   -17015.158    326.95645    326.95645    68257.308    68257.308    702.10352    702.10352 
   27000   -16836.289   -16836.289    -17009.43    -17009.43    334.95158    334.95158    68306.664    68306.664    160.66772    160.66772 
Loop time of 44.6057 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.937 ns/day, 12.390 hours/ns, 22.419 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    | 43.479     | 43.479     | 43.479     |   0.0 | 97.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16851    | 0.16851    | 0.16851    |   0.0 |  0.38
Output  | 0.00018028 | 0.00018028 | 0.00018028 |   0.0 |  0.00
Modify  | 0.85169    | 0.85169    | 0.85169    |   0.0 |  1.91
Other   |            | 0.1066     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411872.0 ave      411872 max      411872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411872
Ave neighs/atom = 102.96800
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 = 332.805191971039, Press = -0.242208776258503
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -16836.289   -16836.289    -17009.43    -17009.43    334.95158    334.95158    68306.664    68306.664    160.66772    160.66772 
   28000   -16844.474   -16844.474   -17017.456   -17017.456    334.64452    334.64452     68299.77     68299.77   -678.77866   -678.77866 
Loop time of 44.6017 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.937 ns/day, 12.389 hours/ns, 22.421 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    | 43.47      | 43.47      | 43.47      |   0.0 | 97.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17109    | 0.17109    | 0.17109    |   0.0 |  0.38
Output  | 0.00018647 | 0.00018647 | 0.00018647 |   0.0 |  0.00
Modify  | 0.85371    | 0.85371    | 0.85371    |   0.0 |  1.91
Other   |            | 0.1065     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411390.0 ave      411390 max      411390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411390
Ave neighs/atom = 102.84750
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 = 332.800758742268, Press = 0.668425022411016
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -16844.474   -16844.474   -17017.456   -17017.456    334.64452    334.64452     68299.77     68299.77   -678.77866   -678.77866 
   29000    -16841.01    -16841.01   -17012.265   -17012.265    331.30459    331.30459    68277.748    68277.748    502.01392    502.01392 
Loop time of 44.6216 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.936 ns/day, 12.395 hours/ns, 22.411 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    | 43.49      | 43.49      | 43.49      |   0.0 | 97.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16988    | 0.16988    | 0.16988    |   0.0 |  0.38
Output  | 0.00018454 | 0.00018454 | 0.00018454 |   0.0 |  0.00
Modify  | 0.85694    | 0.85694    | 0.85694    |   0.0 |  1.92
Other   |            | 0.1051     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411150.0 ave      411150 max      411150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411150
Ave neighs/atom = 102.78750
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 = 332.84223828913, Press = 2.10511803081251
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -16841.01    -16841.01   -17012.265   -17012.265    331.30459    331.30459    68277.748    68277.748    502.01392    502.01392 
   30000   -16842.821   -16842.821   -17011.769   -17011.769    326.84284    326.84284     68397.48     68397.48   -2589.9518   -2589.9518 
Loop time of 44.6419 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.935 ns/day, 12.401 hours/ns, 22.400 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 43.501     | 43.501     | 43.501     |   0.0 | 97.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17046    | 0.17046    | 0.17046    |   0.0 |  0.38
Output  | 0.00018499 | 0.00018499 | 0.00018499 |   0.0 |  0.00
Modify  | 0.86379    | 0.86379    | 0.86379    |   0.0 |  1.93
Other   |            | 0.1065     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411740.0 ave      411740 max      411740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411740
Ave neighs/atom = 102.93500
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 = 332.819561710929, Press = 0.706277633917775
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -16842.821   -16842.821   -17011.769   -17011.769    326.84284    326.84284     68397.48     68397.48   -2589.9518   -2589.9518 
   31000   -16838.741   -16838.741    -17011.21    -17011.21    333.65213    333.65213    68298.187    68298.187    43.673194    43.673194 
Loop time of 44.2595 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.952 ns/day, 12.294 hours/ns, 22.594 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 43.129     | 43.129     | 43.129     |   0.0 | 97.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17058    | 0.17058    | 0.17058    |   0.0 |  0.39
Output  | 0.00022341 | 0.00022341 | 0.00022341 |   0.0 |  0.00
Modify  | 0.85519    | 0.85519    | 0.85519    |   0.0 |  1.93
Other   |            | 0.1043     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      409334.0 ave      409334 max      409334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 409334
Ave neighs/atom = 102.33350
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 = 332.767235756584, Press = 0.521437005501904
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -16838.741   -16838.741    -17011.21    -17011.21    333.65213    333.65213    68298.187    68298.187    43.673194    43.673194 
   32000   -16840.581   -16840.581   -17012.867   -17012.867    333.29745    333.29745    68365.372    68365.372   -1725.6919   -1725.6919 
Loop time of 42.8592 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.016 ns/day, 11.905 hours/ns, 23.332 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    | 41.782     | 41.782     | 41.782     |   0.0 | 97.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16185    | 0.16185    | 0.16185    |   0.0 |  0.38
Output  | 0.0001827  | 0.0001827  | 0.0001827  |   0.0 |  0.00
Modify  | 0.81077    | 0.81077    | 0.81077    |   0.0 |  1.89
Other   |            | 0.1039     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      411362.0 ave      411362 max      411362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 411362
Ave neighs/atom = 102.84050
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 = 332.842930774648, Press = -0.626761090333208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -16840.581   -16840.581   -17012.867   -17012.867    333.29745    333.29745    68365.372    68365.372   -1725.6919   -1725.6919 
   33000   -16835.044   -16835.044   -17006.489   -17006.489    331.67095    331.67095     68365.99     68365.99   -1053.1246   -1053.1246 
Loop time of 38.5594 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.241 ns/day, 10.711 hours/ns, 25.934 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    | 37.644     | 37.644     | 37.644     |   0.0 | 97.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14092    | 0.14092    | 0.14092    |   0.0 |  0.37
Output  | 0.00017698 | 0.00017698 | 0.00017698 |   0.0 |  0.00
Modify  | 0.67312    | 0.67312    | 0.67312    |   0.0 |  1.75
Other   |            | 0.1015     |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      409998.0 ave      409998 max      409998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 409998
Ave neighs/atom = 102.49950
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 = 332.895600363673, Press = 0.293894168431241
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -16835.044   -16835.044   -17006.489   -17006.489    331.67095    331.67095     68365.99     68365.99   -1053.1246   -1053.1246 
   34000   -16843.194   -16843.194   -17011.291   -17011.291    325.19532    325.19532    68254.739    68254.739    1330.6265    1330.6265 
Loop time of 38.6374 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.236 ns/day, 10.733 hours/ns, 25.882 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    | 37.719     | 37.719     | 37.719     |   0.0 | 97.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14174    | 0.14174    | 0.14174    |   0.0 |  0.37
Output  | 0.00017707 | 0.00017707 | 0.00017707 |   0.0 |  0.00
Modify  | 0.67408    | 0.67408    | 0.67408    |   0.0 |  1.74
Other   |            | 0.1025     |            |       |  0.27

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410366.0 ave      410366 max      410366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410366
Ave neighs/atom = 102.59150
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 = 332.905627708611, Press = 0.694267517723492
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -16843.194   -16843.194   -17011.291   -17011.291    325.19532    325.19532    68254.739    68254.739    1330.6265    1330.6265 
   35000    -16836.85    -16836.85   -17011.032   -17011.032    336.96837    336.96837    68382.453    68382.453   -1967.6434   -1967.6434 
Loop time of 38.6687 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.234 ns/day, 10.741 hours/ns, 25.861 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    | 37.751     | 37.751     | 37.751     |   0.0 | 97.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14182    | 0.14182    | 0.14182    |   0.0 |  0.37
Output  | 0.00017984 | 0.00017984 | 0.00017984 |   0.0 |  0.00
Modify  | 0.67437    | 0.67437    | 0.67437    |   0.0 |  1.74
Other   |            | 0.1011     |            |       |  0.26

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      412122.0 ave      412122 max      412122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 412122
Ave neighs/atom = 103.03050
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 = 332.922833667967, Press = -0.336653153125176
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -16836.85    -16836.85   -17011.032   -17011.032    336.96837    336.96837    68382.453    68382.453   -1967.6434   -1967.6434 
   36000   -16840.745   -16840.745   -17012.335   -17012.335    331.95259    331.95259    68318.738    68318.738   -489.91072   -489.91072 
Loop time of 43.4287 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.989 ns/day, 12.064 hours/ns, 23.026 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    | 42.339     | 42.339     | 42.339     |   0.0 | 97.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16549    | 0.16549    | 0.16549    |   0.0 |  0.38
Output  | 0.00018264 | 0.00018264 | 0.00018264 |   0.0 |  0.00
Modify  | 0.81868    | 0.81868    | 0.81868    |   0.0 |  1.89
Other   |            | 0.1049     |            |       |  0.24

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      409206.0 ave      409206 max      409206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 409206
Ave neighs/atom = 102.30150
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 = 332.973133839359, Press = 0.912066240553245
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -16840.745   -16840.745   -17012.335   -17012.335    331.95259    331.95259    68318.738    68318.738   -489.91072   -489.91072 
   37000   -16843.739   -16843.739   -17014.228   -17014.228    329.82329    329.82329    68301.992    68301.992   -448.16249   -448.16249 
Loop time of 38.9765 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.217 ns/day, 10.827 hours/ns, 25.656 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    | 38.056     | 38.056     | 38.056     |   0.0 | 97.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1443     | 0.1443     | 0.1443     |   0.0 |  0.37
Output  | 0.00017692 | 0.00017692 | 0.00017692 |   0.0 |  0.00
Modify  | 0.67765    | 0.67765    | 0.67765    |   0.0 |  1.74
Other   |            | 0.0981     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410906.0 ave      410906 max      410906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410906
Ave neighs/atom = 102.72650
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 = 332.94974562433, Press = 0.984755487420915
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -16843.739   -16843.739   -17014.228   -17014.228    329.82329    329.82329    68301.992    68301.992   -448.16249   -448.16249 
   38000   -16841.792   -16841.792   -17014.993   -17014.993    335.07066    335.07066    68347.532    68347.532   -1619.9459   -1619.9459 
Loop time of 42.0906 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.053 ns/day, 11.692 hours/ns, 23.758 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    | 41.037     | 41.037     | 41.037     |   0.0 | 97.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15907    | 0.15907    | 0.15907    |   0.0 |  0.38
Output  | 0.00017756 | 0.00017756 | 0.00017756 |   0.0 |  0.00
Modify  | 0.79022    | 0.79022    | 0.79022    |   0.0 |  1.88
Other   |            | 0.1041     |            |       |  0.25

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      410742.0 ave      410742 max      410742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 410742
Ave neighs/atom = 102.68550
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
68298.9228498499

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0