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

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

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

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtNi__MO_020840179467_002
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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  -17648.467     -17648.467     -17800         -17800          293.15         293.15         43665.964      43665.964      3706.5672      3706.5672    
      1000  -17481.599     -17481.599     -17643.271     -17643.271      312.76614      312.76614      44145.559      44145.559      3424.9576      3424.9576    
Loop time of 436.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.254 hours/ns, 2.291 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    | 435.6      | 435.6      | 435.6      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14554    | 0.14554    | 0.14554    |   0.0 |  0.03
Output  | 0.00024531 | 0.00024531 | 0.00024531 |   0.0 |  0.00
Modify  | 0.67656    | 0.67656    | 0.67656    |   0.0 |  0.15
Other   |            | 0.09705    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       344000 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      1000  -17481.599     -17481.599     -17643.271     -17643.271      312.76614      312.76614      44145.559      44145.559      3424.9576      3424.9576    
      2000  -17492.918     -17492.918     -17649.232     -17649.232      302.40073      302.40073      44191.454      44191.454     -987.83559     -987.83559    
Loop time of 519.492 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.166 ns/day, 144.303 hours/ns, 1.925 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    | 518.4      | 518.4      | 518.4      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16427    | 0.16427    | 0.16427    |   0.0 |  0.03
Output  | 0.00030129 | 0.00030129 | 0.00030129 |   0.0 |  0.00
Modify  | 0.81971    | 0.81971    | 0.81971    |   0.0 |  0.16
Other   |            | 0.1077     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363212 ave      363212 max      363212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363212
Ave neighs/atom = 90.803
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      2000  -17492.918     -17492.918     -17649.232     -17649.232      302.40073      302.40073      44191.454      44191.454     -987.83559     -987.83559    
      3000  -17496.641     -17496.641     -17645.614     -17645.614      288.19846      288.19846      44186.725      44186.725     -100.15642     -100.15642    
Loop time of 472.818 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.338 hours/ns, 2.115 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    | 471.86     | 471.86     | 471.86     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14917    | 0.14917    | 0.14917    |   0.0 |  0.03
Output  | 0.00023176 | 0.00023176 | 0.00023176 |   0.0 |  0.00
Modify  | 0.71166    | 0.71166    | 0.71166    |   0.0 |  0.15
Other   |            | 0.1001     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       361942 ave      361942 max      361942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361942
Ave neighs/atom = 90.4855
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      3000  -17496.641     -17496.641     -17645.614     -17645.614      288.19846      288.19846      44186.725      44186.725     -100.15642     -100.15642    
      4000  -17492.425     -17492.425     -17646.362     -17646.362      297.8022       297.8022       44185.307      44185.307      50.790462      50.790462    
Loop time of 482.398 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 133.999 hours/ns, 2.073 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    | 481.42     | 481.42     | 481.42     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15127    | 0.15127    | 0.15127    |   0.0 |  0.03
Output  | 0.00026093 | 0.00026093 | 0.00026093 |   0.0 |  0.00
Modify  | 0.72183    | 0.72183    | 0.72183    |   0.0 |  0.15
Other   |            | 0.1014     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362834 ave      362834 max      362834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362834
Ave neighs/atom = 90.7085
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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      4000  -17492.425     -17492.425     -17646.362     -17646.362      297.8022       297.8022       44185.307      44185.307      50.790462      50.790462    
      5000  -17494.964     -17494.964     -17643.939     -17643.939      288.20314      288.20314      44224.979      44224.979     -2368.9154     -2368.9154    
Loop time of 473.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.610 hours/ns, 2.111 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    | 472.83     | 472.83     | 472.83     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15067    | 0.15067    | 0.15067    |   0.0 |  0.03
Output  | 0.00031283 | 0.00031283 | 0.00031283 |   0.0 |  0.00
Modify  | 0.7188     | 0.7188     | 0.7188     |   0.0 |  0.15
Other   |            | 0.09983    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363032 ave      363032 max      363032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363032
Ave neighs/atom = 90.758
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 = 295.498579732151, Press = 291.998206552785
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      5000  -17494.964     -17494.964     -17643.939     -17643.939      288.20314      288.20314      44224.979      44224.979     -2368.9154     -2368.9154    
      6000  -17490.527     -17490.527     -17641.585     -17641.585      292.23173      292.23173      44201.739      44201.739     -204.1205      -204.1205     
Loop time of 492.427 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.175 ns/day, 136.785 hours/ns, 2.031 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    | 491.38     | 491.38     | 491.38     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15563    | 0.15563    | 0.15563    |   0.0 |  0.03
Output  | 0.00019664 | 0.00019664 | 0.00019664 |   0.0 |  0.00
Modify  | 0.78842    | 0.78842    | 0.78842    |   0.0 |  0.16
Other   |            | 0.1051     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362102 ave      362102 max      362102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362102
Ave neighs/atom = 90.5255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.955118035418, Press = 78.5961104350746
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      6000  -17490.527     -17490.527     -17641.585     -17641.585      292.23173      292.23173      44201.739      44201.739     -204.1205      -204.1205     
      7000  -17496.27      -17496.27      -17645.653     -17645.653      288.99107      288.99107      44187.521      44187.521     -82.945429     -82.945429    
Loop time of 495.671 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.174 ns/day, 137.686 hours/ns, 2.017 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    | 494.61     | 494.61     | 494.61     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15723    | 0.15723    | 0.15723    |   0.0 |  0.03
Output  | 0.00019125 | 0.00019125 | 0.00019125 |   0.0 |  0.00
Modify  | 0.80003    | 0.80003    | 0.80003    |   0.0 |  0.16
Other   |            | 0.1037     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363100 ave      363100 max      363100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363100
Ave neighs/atom = 90.775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.262758285019, Press = 67.4595758767382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      7000  -17496.27      -17496.27      -17645.653     -17645.653      288.99107      288.99107      44187.521      44187.521     -82.945429     -82.945429    
      8000  -17487.983     -17487.983     -17642.88      -17642.88       299.65765      299.65765      44165.217      44165.217      2134.8377      2134.8377    
Loop time of 495.632 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.174 ns/day, 137.675 hours/ns, 2.018 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    | 494.59     | 494.59     | 494.59     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15559    | 0.15559    | 0.15559    |   0.0 |  0.03
Output  | 0.00030703 | 0.00030703 | 0.00030703 |   0.0 |  0.00
Modify  | 0.78549    | 0.78549    | 0.78549    |   0.0 |  0.16
Other   |            | 0.1026     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362224 ave      362224 max      362224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362224
Ave neighs/atom = 90.556
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.213849962681, Press = 21.6370786919096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      8000  -17487.983     -17487.983     -17642.88      -17642.88       299.65765      299.65765      44165.217      44165.217      2134.8377      2134.8377    
      9000  -17492.355     -17492.355     -17644.38      -17644.38       294.10292      294.10292      44227.236      44227.236     -2659.0668     -2659.0668    
Loop time of 449.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.824 hours/ns, 2.225 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    | 448.45     | 448.45     | 448.45     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14428    | 0.14428    | 0.14428    |   0.0 |  0.03
Output  | 0.00019238 | 0.00019238 | 0.00019238 |   0.0 |  0.00
Modify  | 0.67728    | 0.67728    | 0.67728    |   0.0 |  0.15
Other   |            | 0.09334    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363564 ave      363564 max      363564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363564
Ave neighs/atom = 90.891
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.334683829989, Press = 4.11599760243351
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
      9000  -17492.355     -17492.355     -17644.38      -17644.38       294.10292      294.10292      44227.236      44227.236     -2659.0668     -2659.0668    
     10000  -17496.637     -17496.637     -17645.283     -17645.283      287.56478      287.56478      44175.762      44175.762      879.49985      879.49985    
Loop time of 446.054 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.904 hours/ns, 2.242 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    | 445.15     | 445.15     | 445.15     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14201    | 0.14201    | 0.14201    |   0.0 |  0.03
Output  | 0.00019025 | 0.00019025 | 0.00019025 |   0.0 |  0.00
Modify  | 0.67215    | 0.67215    | 0.67215    |   0.0 |  0.15
Other   |            | 0.09296    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362764 ave      362764 max      362764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362764
Ave neighs/atom = 90.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.442742270242, Press = 10.7786414750748
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     10000  -17496.637     -17496.637     -17645.283     -17645.283      287.56478      287.56478      44175.762      44175.762      879.49985      879.49985    
     11000  -17496.175     -17496.175     -17644.484     -17644.484      286.91365      286.91365      44195.909      44195.909     -439.13118     -439.13118    
Loop time of 464.041 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.900 hours/ns, 2.155 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    | 463.08     | 463.08     | 463.08     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14805    | 0.14805    | 0.14805    |   0.0 |  0.03
Output  | 0.00018938 | 0.00018938 | 0.00018938 |   0.0 |  0.00
Modify  | 0.71362    | 0.71362    | 0.71362    |   0.0 |  0.15
Other   |            | 0.09691    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362936 ave      362936 max      362936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362936
Ave neighs/atom = 90.734
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.441198829003, Press = 12.6058552399205
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     11000  -17496.175     -17496.175     -17644.484     -17644.484      286.91365      286.91365      44195.909      44195.909     -439.13118     -439.13118    
     12000  -17493.902     -17493.902     -17644.097     -17644.097      290.56067      290.56067      44213.734      44213.734     -1516.0505     -1516.0505    
Loop time of 463.912 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.864 hours/ns, 2.156 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    | 462.95     | 462.95     | 462.95     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14962    | 0.14962    | 0.14962    |   0.0 |  0.03
Output  | 0.00019385 | 0.00019385 | 0.00019385 |   0.0 |  0.00
Modify  | 0.7136     | 0.7136     | 0.7136     |   0.0 |  0.15
Other   |            | 0.09692    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362628 ave      362628 max      362628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362628
Ave neighs/atom = 90.657
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.34942592847, Press = 8.81125993109971
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     12000  -17493.902     -17493.902     -17644.097     -17644.097      290.56067      290.56067      44213.734      44213.734     -1516.0505     -1516.0505    
     13000  -17493.924     -17493.924     -17645.928     -17645.928      294.06239      294.06239      44175.243      44175.243      695.52607      695.52607    
Loop time of 447.281 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.245 hours/ns, 2.236 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    | 446.37     | 446.37     | 446.37     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14433    | 0.14433    | 0.14433    |   0.0 |  0.03
Output  | 0.00023393 | 0.00023393 | 0.00023393 |   0.0 |  0.00
Modify  | 0.67326    | 0.67326    | 0.67326    |   0.0 |  0.15
Other   |            | 0.0935     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362542 ave      362542 max      362542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362542
Ave neighs/atom = 90.6355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.431004049234, Press = 7.06797197552203
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     13000  -17493.924     -17493.924     -17645.928     -17645.928      294.06239      294.06239      44175.243      44175.243      695.52607      695.52607    
     14000  -17494.876     -17494.876     -17644.926     -17644.926      290.28033      290.28033      44198.586      44198.586     -564.36082     -564.36082    
Loop time of 447.123 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.201 hours/ns, 2.237 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 446.21     | 446.21     | 446.21     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1445     | 0.1445     | 0.1445     |   0.0 |  0.03
Output  | 0.00019474 | 0.00019474 | 0.00019474 |   0.0 |  0.00
Modify  | 0.67438    | 0.67438    | 0.67438    |   0.0 |  0.15
Other   |            | 0.094      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362984 ave      362984 max      362984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362984
Ave neighs/atom = 90.746
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.369991988205, Press = 5.79221446285164
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     14000  -17494.876     -17494.876     -17644.926     -17644.926      290.28033      290.28033      44198.586      44198.586     -564.36082     -564.36082    
     15000  -17488.908     -17488.908     -17643.166     -17643.166      298.42181      298.42181      44195.414      44195.414     -1.6873117     -1.6873117    
Loop time of 447.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.182 hours/ns, 2.237 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 446.14     | 446.14     | 446.14     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14436    | 0.14436    | 0.14436    |   0.0 |  0.03
Output  | 0.00019026 | 0.00019026 | 0.00019026 |   0.0 |  0.00
Modify  | 0.6742     | 0.6742     | 0.6742     |   0.0 |  0.15
Other   |            | 0.09421    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362164 ave      362164 max      362164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362164
Ave neighs/atom = 90.541
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.465126671888, Press = 6.31992266137681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     15000  -17488.908     -17488.908     -17643.166     -17643.166      298.42181      298.42181      44195.414      44195.414     -1.6873117     -1.6873117    
     16000  -17489.126     -17489.126     -17640.477     -17640.477      292.79933      292.79933      44192.388      44192.388      662.57355      662.57355    
Loop time of 446.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.061 hours/ns, 2.239 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    | 445.71     | 445.71     | 445.71     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14285    | 0.14285    | 0.14285    |   0.0 |  0.03
Output  | 0.00019352 | 0.00019352 | 0.00019352 |   0.0 |  0.00
Modify  | 0.67439    | 0.67439    | 0.67439    |   0.0 |  0.15
Other   |            | 0.09379    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362872 ave      362872 max      362872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362872
Ave neighs/atom = 90.718
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.496284722497, Press = 1.85298897307064
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     16000  -17489.126     -17489.126     -17640.477     -17640.477      292.79933      292.79933      44192.388      44192.388      662.57355      662.57355    
     17000  -17494.019     -17494.019     -17645.611     -17645.611      293.26606      293.26606      44220.399      44220.399     -2300.08       -2300.08      
Loop time of 461.331 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.147 hours/ns, 2.168 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 460.38     | 460.38     | 460.38     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14667    | 0.14667    | 0.14667    |   0.0 |  0.03
Output  | 0.00019711 | 0.00019711 | 0.00019711 |   0.0 |  0.00
Modify  | 0.70881    | 0.70881    | 0.70881    |   0.0 |  0.15
Other   |            | 0.09789    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362990 ave      362990 max      362990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362990
Ave neighs/atom = 90.7475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.505090944478, Press = 4.11553141760627
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     17000  -17494.019     -17494.019     -17645.611     -17645.611      293.26606      293.26606      44220.399      44220.399     -2300.08       -2300.08      
     18000  -17492.927     -17492.927     -17644.58      -17644.58       293.3835       293.3835       44181.115      44181.115      481.367        481.367      
Loop time of 464.917 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.144 hours/ns, 2.151 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    | 463.95     | 463.95     | 463.95     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15052    | 0.15052    | 0.15052    |   0.0 |  0.03
Output  | 0.00019775 | 0.00019775 | 0.00019775 |   0.0 |  0.00
Modify  | 0.72233    | 0.72233    | 0.72233    |   0.0 |  0.16
Other   |            | 0.09765    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       361736 ave      361736 max      361736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361736
Ave neighs/atom = 90.434
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.409547440514, Press = 4.86214739687161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     18000  -17492.927     -17492.927     -17644.58      -17644.58       293.3835       293.3835       44181.115      44181.115      481.367        481.367      
     19000  -17494.234     -17494.234     -17646.481     -17646.481      294.53329      294.53329      44135.655      44135.655      3321.2786      3321.2786    
Loop time of 448.397 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.555 hours/ns, 2.230 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    | 447.48     | 447.48     | 447.48     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14617    | 0.14617    | 0.14617    |   0.0 |  0.03
Output  | 0.00025122 | 0.00025122 | 0.00025122 |   0.0 |  0.00
Modify  | 0.67931    | 0.67931    | 0.67931    |   0.0 |  0.15
Other   |            | 0.09582    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362694 ave      362694 max      362694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362694
Ave neighs/atom = 90.6735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.271146031965, Press = 3.41795179016161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     19000  -17494.234     -17494.234     -17646.481     -17646.481      294.53329      294.53329      44135.655      44135.655      3321.2786      3321.2786    
     20000  -17493.584     -17493.584     -17643.224     -17643.224      289.48812      289.48812      44160.537      44160.537      2179.1743      2179.1743    
Loop time of 464.85 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.125 hours/ns, 2.151 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    | 463.89     | 463.89     | 463.89     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14946    | 0.14946    | 0.14946    |   0.0 |  0.03
Output  | 0.00024822 | 0.00024822 | 0.00024822 |   0.0 |  0.00
Modify  | 0.71379    | 0.71379    | 0.71379    |   0.0 |  0.15
Other   |            | 0.09746    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363678 ave      363678 max      363678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363678
Ave neighs/atom = 90.9195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.210773093734, Press = -2.15286815713752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     20000  -17493.584     -17493.584     -17643.224     -17643.224      289.48812      289.48812      44160.537      44160.537      2179.1743      2179.1743    
     21000  -17494.07      -17494.07      -17645.283     -17645.283      292.53207      292.53207      44205.656      44205.656     -1279.7839     -1279.7839    
Loop time of 494.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.175 ns/day, 137.306 hours/ns, 2.023 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    | 493.25     | 493.25     | 493.25     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15758    | 0.15758    | 0.15758    |   0.0 |  0.03
Output  | 0.00024001 | 0.00024001 | 0.00024001 |   0.0 |  0.00
Modify  | 0.79206    | 0.79206    | 0.79206    |   0.0 |  0.16
Other   |            | 0.1054     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363436 ave      363436 max      363436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363436
Ave neighs/atom = 90.859
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.125475929926, Press = 1.42066487507226
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     21000  -17494.07      -17494.07      -17645.283     -17645.283      292.53207      292.53207      44205.656      44205.656     -1279.7839     -1279.7839    
     22000  -17497.43      -17497.43      -17648.736     -17648.736      292.71305      292.71305      44165.646      44165.646      790.12697      790.12697    
Loop time of 464.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.081 hours/ns, 2.152 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 463.73     | 463.73     | 463.73     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14846    | 0.14846    | 0.14846    |   0.0 |  0.03
Output  | 0.00023561 | 0.00023561 | 0.00023561 |   0.0 |  0.00
Modify  | 0.71763    | 0.71763    | 0.71763    |   0.0 |  0.15
Other   |            | 0.09774    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362348 ave      362348 max      362348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362348
Ave neighs/atom = 90.587
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.137779761317, Press = 4.8944166687683
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     22000  -17497.43      -17497.43      -17648.736     -17648.736      292.71305      292.71305      44165.646      44165.646      790.12697      790.12697    
     23000  -17493.263     -17493.263     -17646.943     -17646.943      297.30455      297.30455      44180.871      44180.871      251.41353      251.41353    
Loop time of 492.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.175 ns/day, 136.854 hours/ns, 2.030 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    | 491.63     | 491.63     | 491.63     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15705    | 0.15705    | 0.15705    |   0.0 |  0.03
Output  | 0.00025008 | 0.00025008 | 0.00025008 |   0.0 |  0.00
Modify  | 0.78584    | 0.78584    | 0.78584    |   0.0 |  0.16
Other   |            | 0.1044     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362594 ave      362594 max      362594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362594
Ave neighs/atom = 90.6485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.112305621728, Press = 2.65865982116997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     23000  -17493.263     -17493.263     -17646.943     -17646.943      297.30455      297.30455      44180.871      44180.871      251.41353      251.41353    
     24000  -17493.835     -17493.835     -17644.9       -17644.9        292.24405      292.24405      44217.343      44217.343     -1951.0688     -1951.0688    
Loop time of 476.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.315 hours/ns, 2.099 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    | 475.34     | 475.34     | 475.34     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1508     | 0.1508     | 0.1508     |   0.0 |  0.03
Output  | 0.00019084 | 0.00019084 | 0.00019084 |   0.0 |  0.00
Modify  | 0.74097    | 0.74097    | 0.74097    |   0.0 |  0.16
Other   |            | 0.09891    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362304 ave      362304 max      362304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362304
Ave neighs/atom = 90.576
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.130789249831, Press = 3.46680974692256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     24000  -17493.835     -17493.835     -17644.9       -17644.9        292.24405      292.24405      44217.343      44217.343     -1951.0688     -1951.0688    
     25000  -17493.534     -17493.534     -17644.289     -17644.289      291.64615      291.64615      44160.207      44160.207      1959.8995      1959.8995    
Loop time of 463.532 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.759 hours/ns, 2.157 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    | 462.56     | 462.56     | 462.56     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14754    | 0.14754    | 0.14754    |   0.0 |  0.03
Output  | 0.00023578 | 0.00023578 | 0.00023578 |   0.0 |  0.00
Modify  | 0.72282    | 0.72282    | 0.72282    |   0.0 |  0.16
Other   |            | 0.09786    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       361992 ave      361992 max      361992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361992
Ave neighs/atom = 90.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.178000699785, Press = 8.42970443606529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     25000  -17493.534     -17493.534     -17644.289     -17644.289      291.64615      291.64615      44160.207      44160.207      1959.8995      1959.8995    
     26000  -17491.513     -17491.513     -17643.122     -17643.122      293.29765      293.29765      44144.083      44144.083      3328.1426      3328.1426    
Loop time of 483.7 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.361 hours/ns, 2.067 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    | 482.68     | 482.68     | 482.68     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15125    | 0.15125    | 0.15125    |   0.0 |  0.03
Output  | 0.00019334 | 0.00019334 | 0.00019334 |   0.0 |  0.00
Modify  | 0.76261    | 0.76261    | 0.76261    |   0.0 |  0.16
Other   |            | 0.1012     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362944 ave      362944 max      362944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362944
Ave neighs/atom = 90.736
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.135504808773, Press = 3.58268107701763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     26000  -17491.513     -17491.513     -17643.122     -17643.122      293.29765      293.29765      44144.083      44144.083      3328.1426      3328.1426    
     27000  -17493.773     -17493.773     -17644.862     -17644.862      292.29299      292.29299      44189.22       44189.22      -133.91098     -133.91098    
Loop time of 486.859 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.239 hours/ns, 2.054 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    | 485.84     | 485.84     | 485.84     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15121    | 0.15121    | 0.15121    |   0.0 |  0.03
Output  | 0.00019472 | 0.00019472 | 0.00019472 |   0.0 |  0.00
Modify  | 0.76663    | 0.76663    | 0.76663    |   0.0 |  0.16
Other   |            | 0.1016     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363798 ave      363798 max      363798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363798
Ave neighs/atom = 90.9495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.143487380306, Press = 2.31326857798132
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     27000  -17493.773     -17493.773     -17644.862     -17644.862      292.29299      292.29299      44189.22       44189.22      -133.91098     -133.91098    
     28000  -17492.546     -17492.546     -17644.614     -17644.614      294.18451      294.18451      44180.577      44180.577      701.07058      701.07058    
Loop time of 499.133 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.173 ns/day, 138.648 hours/ns, 2.003 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    | 498.07     | 498.07     | 498.07     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15522    | 0.15522    | 0.15522    |   0.0 |  0.03
Output  | 0.00019254 | 0.00019254 | 0.00019254 |   0.0 |  0.00
Modify  | 0.80269    | 0.80269    | 0.80269    |   0.0 |  0.16
Other   |            | 0.1039     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362860 ave      362860 max      362860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362860
Ave neighs/atom = 90.715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.135950925169, Press = 5.17487028651313
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     28000  -17492.546     -17492.546     -17644.614     -17644.614      294.18451      294.18451      44180.577      44180.577      701.07058      701.07058    
     29000  -17491.272     -17491.272     -17644.789     -17644.789      296.98942      296.98942      44164.712      44164.712      1594.2751      1594.2751    
Loop time of 473.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.545 hours/ns, 2.112 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    | 472.58     | 472.58     | 472.58     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1474     | 0.1474     | 0.1474     |   0.0 |  0.03
Output  | 0.00019028 | 0.00019028 | 0.00019028 |   0.0 |  0.00
Modify  | 0.73503    | 0.73503    | 0.73503    |   0.0 |  0.16
Other   |            | 0.1005     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363006 ave      363006 max      363006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363006
Ave neighs/atom = 90.7515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.187495968998, Press = 4.58598287926404
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     29000  -17491.272     -17491.272     -17644.789     -17644.789      296.98942      296.98942      44164.712      44164.712      1594.2751      1594.2751    
     30000  -17487.422     -17487.422     -17641.22      -17641.22       297.53216      297.53216      44191.928      44191.928      803.5165       803.5165     
Loop time of 444.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.436 hours/ns, 2.250 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 443.46     | 443.46     | 443.46     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13837    | 0.13837    | 0.13837    |   0.0 |  0.03
Output  | 0.00019127 | 0.00019127 | 0.00019127 |   0.0 |  0.00
Modify  | 0.67073    | 0.67073    | 0.67073    |   0.0 |  0.15
Other   |            | 0.09582    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363486 ave      363486 max      363486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363486
Ave neighs/atom = 90.8715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.189365289523, Press = 2.80129700956672
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     30000  -17487.422     -17487.422     -17641.22      -17641.22       297.53216      297.53216      44191.928      44191.928      803.5165       803.5165     
     31000  -17493.854     -17493.854     -17646.457     -17646.457      295.22065      295.22065      44190.042      44190.042     -381.18658     -381.18658    
Loop time of 461.685 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.246 hours/ns, 2.166 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    | 460.74     | 460.74     | 460.74     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14437    | 0.14437    | 0.14437    |   0.0 |  0.03
Output  | 0.00026533 | 0.00026533 | 0.00026533 |   0.0 |  0.00
Modify  | 0.70592    | 0.70592    | 0.70592    |   0.0 |  0.15
Other   |            | 0.09856    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363138 ave      363138 max      363138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363138
Ave neighs/atom = 90.7845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.201087002166, Press = -0.42057402028571
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     31000  -17493.854     -17493.854     -17646.457     -17646.457      295.22065      295.22065      44190.042      44190.042     -381.18658     -381.18658    
     32000  -17495.647     -17495.647     -17647.096     -17647.096      292.98755      292.98755      44203.365      44203.365     -1368.2103     -1368.2103    
Loop time of 448.149 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.486 hours/ns, 2.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    | 447.23     | 447.23     | 447.23     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14476    | 0.14476    | 0.14476    |   0.0 |  0.03
Output  | 0.00019269 | 0.00019269 | 0.00019269 |   0.0 |  0.00
Modify  | 0.67899    | 0.67899    | 0.67899    |   0.0 |  0.15
Other   |            | 0.09583    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       361914 ave      361914 max      361914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361914
Ave neighs/atom = 90.4785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.263897938812, Press = 0.28087706303139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     32000  -17495.647     -17495.647     -17647.096     -17647.096      292.98755      292.98755      44203.365      44203.365     -1368.2103     -1368.2103    
     33000  -17492.102     -17492.102     -17645.449     -17645.449      296.65909      296.65909      44220.711      44220.711     -2091.2139     -2091.2139    
Loop time of 448.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.557 hours/ns, 2.230 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    | 447.48     | 447.48     | 447.48     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14384    | 0.14384    | 0.14384    |   0.0 |  0.03
Output  | 0.00026973 | 0.00026973 | 0.00026973 |   0.0 |  0.00
Modify  | 0.68106    | 0.68106    | 0.68106    |   0.0 |  0.15
Other   |            | 0.09615    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       361770 ave      361770 max      361770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361770
Ave neighs/atom = 90.4425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.23312432634, Press = 2.06434843584435
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     33000  -17492.102     -17492.102     -17645.449     -17645.449      296.65909      296.65909      44220.711      44220.711     -2091.2139     -2091.2139    
     34000  -17495.355     -17495.355     -17648.126     -17648.126      295.54681      295.54681      44222.124      44222.124     -2872.1372     -2872.1372    
Loop time of 450.614 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.171 hours/ns, 2.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 449.69     | 449.69     | 449.69     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14378    | 0.14378    | 0.14378    |   0.0 |  0.03
Output  | 0.00022381 | 0.00022381 | 0.00022381 |   0.0 |  0.00
Modify  | 0.6828     | 0.6828     | 0.6828     |   0.0 |  0.15
Other   |            | 0.09659    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362110 ave      362110 max      362110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362110
Ave neighs/atom = 90.5275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.177448328144, Press = 4.63360702730219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     34000  -17495.355     -17495.355     -17648.126     -17648.126      295.54681      295.54681      44222.124      44222.124     -2872.1372     -2872.1372    
     35000  -17493.906     -17493.906     -17644.648     -17644.648      291.61913      291.61913      44187.765      44187.765      228.48425      228.48425    
Loop time of 450.861 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.239 hours/ns, 2.218 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    | 449.94     | 449.94     | 449.94     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14489    | 0.14489    | 0.14489    |   0.0 |  0.03
Output  | 0.00023926 | 0.00023926 | 0.00023926 |   0.0 |  0.00
Modify  | 0.6832     | 0.6832     | 0.6832     |   0.0 |  0.15
Other   |            | 0.09674    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       361618 ave      361618 max      361618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 361618
Ave neighs/atom = 90.4045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.229823463969, Press = 3.21092177352697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     35000  -17493.906     -17493.906     -17644.648     -17644.648      291.61913      291.61913      44187.765      44187.765      228.48425      228.48425    
     36000  -17489.54      -17489.54      -17642.162     -17642.162      295.25862      295.25862      44167.374      44167.374      1985.4738      1985.4738    
Loop time of 450.337 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.093 hours/ns, 2.221 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    | 449.41     | 449.41     | 449.41     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14607    | 0.14607    | 0.14607    |   0.0 |  0.03
Output  | 0.00019464 | 0.00019464 | 0.00019464 |   0.0 |  0.00
Modify  | 0.68278    | 0.68278    | 0.68278    |   0.0 |  0.15
Other   |            | 0.09583    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362172 ave      362172 max      362172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362172
Ave neighs/atom = 90.543
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.261065778907, Press = 2.84376351633533
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     36000  -17489.54      -17489.54      -17642.162     -17642.162      295.25862      295.25862      44167.374      44167.374      1985.4738      1985.4738    
     37000  -17497.984     -17497.984     -17646.527     -17646.527      287.36691      287.36691      44148.194      44148.194      2381.8442      2381.8442    
Loop time of 450.679 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.189 hours/ns, 2.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 449.76     | 449.76     | 449.76     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14546    | 0.14546    | 0.14546    |   0.0 |  0.03
Output  | 0.00018341 | 0.00018341 | 0.00018341 |   0.0 |  0.00
Modify  | 0.68152    | 0.68152    | 0.68152    |   0.0 |  0.15
Other   |            | 0.09701    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363320 ave      363320 max      363320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363320
Ave neighs/atom = 90.83
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.270300815056, Press = 2.54907763867793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     37000  -17497.984     -17497.984     -17646.527     -17646.527      287.36691      287.36691      44148.194      44148.194      2381.8442      2381.8442    
     38000  -17492.318     -17492.318     -17644.269     -17644.269      293.96041      293.96041      44182.839      44182.839      536.95623      536.95623    
Loop time of 449.11 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.753 hours/ns, 2.227 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    | 448.19     | 448.19     | 448.19     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14351    | 0.14351    | 0.14351    |   0.0 |  0.03
Output  | 0.00052534 | 0.00052534 | 0.00052534 |   0.0 |  0.00
Modify  | 0.68039    | 0.68039    | 0.68039    |   0.0 |  0.15
Other   |            | 0.09672    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       363408 ave      363408 max      363408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 363408
Ave neighs/atom = 90.852
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.265089499472, Press = 1.42829831102988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     38000  -17492.318     -17492.318     -17644.269     -17644.269      293.96041      293.96041      44182.839      44182.839      536.95623      536.95623    
     39000  -17493.303     -17493.303     -17646.666     -17646.666      296.69015      296.69015      44174.981      44174.981      679.41832      679.41832    
Loop time of 446.119 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.922 hours/ns, 2.242 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    | 445.2      | 445.2      | 445.2      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14281    | 0.14281    | 0.14281    |   0.0 |  0.03
Output  | 0.0001809  | 0.0001809  | 0.0001809  |   0.0 |  0.00
Modify  | 0.67505    | 0.67505    | 0.67505    |   0.0 |  0.15
Other   |            | 0.09678    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362904 ave      362904 max      362904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 362904
Ave neighs/atom = 90.726
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.211873241802, Press = -0.245768140470561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   
     39000  -17493.303     -17493.303     -17646.666     -17646.666      296.69015      296.69015      44174.981      44174.981      679.41832      679.41832    
     40000  -17496.524     -17496.524     -17645.716     -17645.716      288.62346      288.62346      44203.26       44203.26      -1303.852      -1303.852     
Loop time of 436.271 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.186 hours/ns, 2.292 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    | 435.37     | 435.37     | 435.37     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13754    | 0.13754    | 0.13754    |   0.0 |  0.03
Output  | 0.00019085 | 0.00019085 | 0.00019085 |   0.0 |  0.00
Modify  | 0.66585    | 0.66585    | 0.66585    |   0.0 |  0.15
Other   |            | 0.09736    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       362524 ave      362524 max      362524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0