# 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.613315671682358*${_u_distance}
variable latticeconst_converted equal 3.613315671682358*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331567168236
Lattice spacing in x,y,z = 3.6133157 3.6133157 3.6133157
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133157 36.133157 36.133157)
  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 (36.133157 36.133157 36.133157)
  create_atoms CPU = 0.001 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_PtCu__MO_070797404269_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 47175.6305927869    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6305927869/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6305927869/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6305927869/(1*1*${_u_distance})
variable      V0_metal equal 47175.6305927869/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47175.6305927869*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6305927869 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_070797404269_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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14018.806     -14018.806     -14160         -14160          273.15         273.15         47175.631      47175.631      3196.8327      3196.8327    
      1000  -13864.973     -13864.973     -14013.413     -14013.413      287.16717      287.16717      47825.014      47825.014      537.42131      537.42131    
Loop time of 46.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.849 ns/day, 12.979 hours/ns, 21.402 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.573     | 46.573     | 46.573     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021886   | 0.021886   | 0.021886   |   0.0 |  0.05
Output  | 0.00020008 | 0.00020008 | 0.00020008 |   0.0 |  0.00
Modify  | 0.11833    | 0.11833    | 0.11833    |   0.0 |  0.25
Other   |            | 0.01072    |            |       |  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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13864.973     -13864.973     -14013.413     -14013.413      287.16717      287.16717      47825.014      47825.014      537.42131      537.42131    
      2000  -13882.866     -13882.866     -14014.485     -14014.485      254.62628      254.62628      47843.327      47843.327     -814.14549     -814.14549    
Loop time of 50.2085 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.721 ns/day, 13.947 hours/ns, 19.917 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.059     | 50.059     | 50.059     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021627   | 0.021627   | 0.021627   |   0.0 |  0.04
Output  | 8.7505e-05 | 8.7505e-05 | 8.7505e-05 |   0.0 |  0.00
Modify  | 0.11744    | 0.11744    | 0.11744    |   0.0 |  0.23
Other   |            | 0.01042    |            |       |  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:       343684 ave      343684 max      343684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343684
Ave neighs/atom = 85.921
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13882.866     -13882.866     -14014.485     -14014.485      254.62628      254.62628      47843.327      47843.327     -814.14549     -814.14549    
      3000  -13871.4       -13871.4       -14014.097     -14014.097      276.05779      276.05779      47831.15       47831.15       118.12054      118.12054    
Loop time of 50.2421 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.720 ns/day, 13.956 hours/ns, 19.904 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.093     | 50.093     | 50.093     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021622   | 0.021622   | 0.021622   |   0.0 |  0.04
Output  | 8.6532e-05 | 8.6532e-05 | 8.6532e-05 |   0.0 |  0.00
Modify  | 0.11737    | 0.11737    | 0.11737    |   0.0 |  0.23
Other   |            | 0.01041    |            |       |  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:       343716 ave      343716 max      343716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343716
Ave neighs/atom = 85.929
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13871.4       -13871.4       -14014.097     -14014.097      276.05779      276.05779      47831.15       47831.15       118.12054      118.12054    
      4000  -13882.468     -13882.468     -14019.541     -14019.541      265.17796      265.17796      47780.406      47780.406      1193.2546      1193.2546    
Loop time of 50.3331 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.717 ns/day, 13.981 hours/ns, 19.868 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.183     | 50.183     | 50.183     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021713   | 0.021713   | 0.021713   |   0.0 |  0.04
Output  | 8.1193e-05 | 8.1193e-05 | 8.1193e-05 |   0.0 |  0.00
Modify  | 0.11741    | 0.11741    | 0.11741    |   0.0 |  0.23
Other   |            | 0.01042    |            |       |  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:       343632 ave      343632 max      343632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343632
Ave neighs/atom = 85.908
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13882.468     -13882.468     -14019.541     -14019.541      265.17796      265.17796      47780.406      47780.406      1193.2546      1193.2546    
      5000  -13871.132     -13871.132     -14015.286     -14015.286      278.87465      278.87465      47867.323      47867.323     -1901.101      -1901.101     
Loop time of 50.3199 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.717 ns/day, 13.978 hours/ns, 19.873 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.17      | 50.17      | 50.17      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021594   | 0.021594   | 0.021594   |   0.0 |  0.04
Output  | 3.8081e-05 | 3.8081e-05 | 3.8081e-05 |   0.0 |  0.00
Modify  | 0.11778    | 0.11778    | 0.11778    |   0.0 |  0.23
Other   |            | 0.01036    |            |       |  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:       343816 ave      343816 max      343816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343816
Ave neighs/atom = 85.954
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 = 280.544042311576, Press = 443.181422210078
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13871.132     -13871.132     -14015.286     -14015.286      278.87465      278.87465      47867.323      47867.323     -1901.101      -1901.101     
      6000  -13878.147     -13878.147     -14015.812     -14015.812      266.32176      266.32176      47828.743      47828.743     -332.34189     -332.34189    
Loop time of 50.4211 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.714 ns/day, 14.006 hours/ns, 19.833 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.268     | 50.268     | 50.268     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021508   | 0.021508   | 0.021508   |   0.0 |  0.04
Output  | 6.5402e-05 | 6.5402e-05 | 6.5402e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.24
Other   |            | 0.01042    |            |       |  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:       343766 ave      343766 max      343766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343766
Ave neighs/atom = 85.9415
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 = 273.240025236655, Press = 18.323976811116
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13878.147     -13878.147     -14015.812     -14015.812      266.32176      266.32176      47828.743      47828.743     -332.34189     -332.34189    
      7000  -13874.625     -13874.625     -14017.979     -14017.979      277.32796      277.32796      47781.053      47781.053      1712.3744      1712.3744    
Loop time of 50.4192 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.714 ns/day, 14.005 hours/ns, 19.834 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.266     | 50.266     | 50.266     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021685   | 0.021685   | 0.021685   |   0.0 |  0.04
Output  | 7.5272e-05 | 7.5272e-05 | 7.5272e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.24
Other   |            | 0.01041    |            |       |  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:       343780 ave      343780 max      343780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343780
Ave neighs/atom = 85.945
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 = 273.404358939277, Press = 31.1220959323283
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13874.625     -13874.625     -14017.979     -14017.979      277.32796      277.32796      47781.053      47781.053      1712.3744      1712.3744    
      8000  -13881.134     -13881.134     -14018.246     -14018.246      265.2515       265.2515       47804.874      47804.874      352.65004      352.65004    
Loop time of 50.4085 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.714 ns/day, 14.002 hours/ns, 19.838 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.255     | 50.255     | 50.255     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021596   | 0.021596   | 0.021596   |   0.0 |  0.04
Output  | 5.9792e-05 | 5.9792e-05 | 5.9792e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.24
Other   |            | 0.01044    |            |       |  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:       343774 ave      343774 max      343774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343774
Ave neighs/atom = 85.9435
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 = 273.127021113835, Press = 36.8193773381377
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13881.134     -13881.134     -14018.246     -14018.246      265.2515       265.2515       47804.874      47804.874      352.65004      352.65004    
      9000  -13874.921     -13874.921     -14017.934     -14017.934      276.66855      276.66855      47864.585      47864.585     -2205.0641     -2205.0641    
Loop time of 50.4324 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.713 ns/day, 14.009 hours/ns, 19.829 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.279     | 50.279     | 50.279     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021562   | 0.021562   | 0.021562   |   0.0 |  0.04
Output  | 5.6516e-05 | 5.6516e-05 | 5.6516e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.24
Other   |            | 0.01041    |            |       |  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:       343776 ave      343776 max      343776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343776
Ave neighs/atom = 85.944
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 = 272.994098280422, Press = 5.89021355870819
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13874.921     -13874.921     -14017.934     -14017.934      276.66855      276.66855      47864.585      47864.585     -2205.0641     -2205.0641    
     10000  -13876.219     -13876.219     -14017.396     -14017.396      273.11728      273.11728      47830.291      47830.291     -509.6419      -509.6419     
Loop time of 50.3921 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.715 ns/day, 13.998 hours/ns, 19.844 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.239     | 50.239     | 50.239     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021612   | 0.021612   | 0.021612   |   0.0 |  0.04
Output  | 6.0654e-05 | 6.0654e-05 | 6.0654e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.24
Other   |            | 0.01042    |            |       |  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:       343756 ave      343756 max      343756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343756
Ave neighs/atom = 85.939
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 = 273.204177239409, Press = 6.06002431354415
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13876.219     -13876.219     -14017.396     -14017.396      273.11728      273.11728      47830.291      47830.291     -509.6419      -509.6419     
     11000  -13878.632     -13878.632     -14019.032     -14019.032      271.61292      271.61292      47835.584      47835.584     -1026.0897     -1026.0897    
Loop time of 50.4665 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.712 ns/day, 14.018 hours/ns, 19.815 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.313     | 50.313     | 50.313     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021599   | 0.021599   | 0.021599   |   0.0 |  0.04
Output  | 3.7581e-05 | 3.7581e-05 | 3.7581e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.24
Other   |            | 0.01037    |            |       |  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:       343786 ave      343786 max      343786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343786
Ave neighs/atom = 85.9465
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 = 273.301258642574, Press = 2.06982512028295
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13878.632     -13878.632     -14019.032     -14019.032      271.61292      271.61292      47835.584      47835.584     -1026.0897     -1026.0897    
     12000  -13874.462     -13874.462     -14015.405     -14015.405      272.66316      272.66316      47821.758      47821.758      243.04966      243.04966    
Loop time of 50.4034 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.714 ns/day, 14.001 hours/ns, 19.840 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.25      | 50.25      | 50.25      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021486   | 0.021486   | 0.021486   |   0.0 |  0.04
Output  | 7.3739e-05 | 7.3739e-05 | 7.3739e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.24
Other   |            | 0.0104     |            |       |  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:       343698 ave      343698 max      343698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343698
Ave neighs/atom = 85.9245
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 = 273.19903189913, Press = 5.05363705333352
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13874.462     -13874.462     -14015.405     -14015.405      272.66316      272.66316      47821.758      47821.758      243.04966      243.04966    
     13000  -13875.791     -13875.791     -14018.385     -14018.385      275.85867      275.85867      47808.265      47808.265      302.43612      302.43612    
Loop time of 50.3591 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.716 ns/day, 13.989 hours/ns, 19.857 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.206     | 50.206     | 50.206     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021525   | 0.021525   | 0.021525   |   0.0 |  0.04
Output  | 7.3317e-05 | 7.3317e-05 | 7.3317e-05 |   0.0 |  0.00
Modify  | 0.12128    | 0.12128    | 0.12128    |   0.0 |  0.24
Other   |            | 0.01039    |            |       |  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:       343692 ave      343692 max      343692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343692
Ave neighs/atom = 85.923
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 = 273.075268288772, Press = 4.97593559263953
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13875.791     -13875.791     -14018.385     -14018.385      275.85867      275.85867      47808.265      47808.265      302.43612      302.43612    
     14000  -13874.115     -13874.115     -14014.247     -14014.247      271.09415      271.09415      47789.829      47789.829      1885.7096      1885.7096    
Loop time of 50.4152 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.714 ns/day, 14.004 hours/ns, 19.835 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.262     | 50.262     | 50.262     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021658   | 0.021658   | 0.021658   |   0.0 |  0.04
Output  | 5.9662e-05 | 5.9662e-05 | 5.9662e-05 |   0.0 |  0.00
Modify  | 0.1211     | 0.1211     | 0.1211     |   0.0 |  0.24
Other   |            | 0.0104     |            |       |  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:       343752 ave      343752 max      343752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343752
Ave neighs/atom = 85.938
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 = 273.155634492469, Press = 5.04604337029517
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13874.115     -13874.115     -14014.247     -14014.247      271.09415      271.09415      47789.829      47789.829      1885.7096      1885.7096    
     15000  -13878.045     -13878.045     -14017.434     -14017.434      269.65755      269.65755      47781.089      47781.089      1654.8863      1654.8863    
Loop time of 50.4377 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.713 ns/day, 14.010 hours/ns, 19.826 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.284     | 50.284     | 50.284     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021612   | 0.021612   | 0.021612   |   0.0 |  0.04
Output  | 6.0333e-05 | 6.0333e-05 | 6.0333e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.24
Other   |            | 0.01041    |            |       |  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:       343770 ave      343770 max      343770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343770
Ave neighs/atom = 85.9425
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 = 273.115812066251, Press = 8.60907699669013
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13878.045     -13878.045     -14017.434     -14017.434      269.65755      269.65755      47781.089      47781.089      1654.8863      1654.8863    
     16000  -13878.909     -13878.909     -14020.598     -14020.598      274.10649      274.10649      47860.186      47860.186     -2422.3069     -2422.3069    
Loop time of 50.5741 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.708 ns/day, 14.048 hours/ns, 19.773 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.42      | 50.42      | 50.42      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021733   | 0.021733   | 0.021733   |   0.0 |  0.04
Output  | 5.8199e-05 | 5.8199e-05 | 5.8199e-05 |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  0.24
Other   |            | 0.01039    |            |       |  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:       343824 ave      343824 max      343824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343824
Ave neighs/atom = 85.956
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 = 273.163184816253, Press = 5.28611338610259
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13878.909     -13878.909     -14020.598     -14020.598      274.10649      274.10649      47860.186      47860.186     -2422.3069     -2422.3069    
     17000  -13879.588     -13879.588     -14019.114     -14019.114      269.92201      269.92201      47827.359      47827.359     -702.47121     -702.47121    
Loop time of 50.5404 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.710 ns/day, 14.039 hours/ns, 19.786 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.386     | 50.386     | 50.386     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0217     | 0.0217     | 0.0217     |   0.0 |  0.04
Output  | 6.8258e-05 | 6.8258e-05 | 6.8258e-05 |   0.0 |  0.00
Modify  | 0.12161    | 0.12161    | 0.12161    |   0.0 |  0.24
Other   |            | 0.01054    |            |       |  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:       343706 ave      343706 max      343706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343706
Ave neighs/atom = 85.9265
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 = 273.129050461164, Press = 4.68623838122966
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13879.588     -13879.588     -14019.114     -14019.114      269.92201      269.92201      47827.359      47827.359     -702.47121     -702.47121    
     18000  -13875.258     -13875.258     -14014.968     -14014.968      270.27806      270.27806      47867.595      47867.595     -1805.6744     -1805.6744    
Loop time of 50.5006 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.711 ns/day, 14.028 hours/ns, 19.802 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.347     | 50.347     | 50.347     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021513   | 0.021513   | 0.021513   |   0.0 |  0.04
Output  | 7.4009e-05 | 7.4009e-05 | 7.4009e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.24
Other   |            | 0.01045    |            |       |  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:       343714 ave      343714 max      343714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343714
Ave neighs/atom = 85.9285
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 = 273.087144872785, Press = 1.93667580861795
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13875.258     -13875.258     -14014.968     -14014.968      270.27806      270.27806      47867.595      47867.595     -1805.6744     -1805.6744    
     19000  -13872.656     -13872.656     -14016.194     -14016.194      277.68501      277.68501      47886.162      47886.162     -2887.437      -2887.437     
Loop time of 50.5834 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.708 ns/day, 14.051 hours/ns, 19.769 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.43      | 50.43      | 50.43      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021584   | 0.021584   | 0.021584   |   0.0 |  0.04
Output  | 7.8167e-05 | 7.8167e-05 | 7.8167e-05 |   0.0 |  0.00
Modify  | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.24
Other   |            | 0.01043    |            |       |  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:       343638 ave      343638 max      343638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343638
Ave neighs/atom = 85.9095
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 = 273.034221829492, Press = 2.31187572134798
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13872.656     -13872.656     -14016.194     -14016.194      277.68501      277.68501      47886.162      47886.162     -2887.437      -2887.437     
     20000  -13876.127     -13876.127     -14017.834     -14017.834      274.14289      274.14289      47808.302      47808.302      306.16129      306.16129    
Loop time of 50.478 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.712 ns/day, 14.022 hours/ns, 19.811 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.325     | 50.325     | 50.325     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021526   | 0.021526   | 0.021526   |   0.0 |  0.04
Output  | 7.8237e-05 | 7.8237e-05 | 7.8237e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.24
Other   |            | 0.01045    |            |       |  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:       343692 ave      343692 max      343692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343692
Ave neighs/atom = 85.923
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 = 273.12343550821, Press = 1.9922176777247
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13876.127     -13876.127     -14017.834     -14017.834      274.14289      274.14289      47808.302      47808.302      306.16129      306.16129    
     21000  -13871.964     -13871.964     -14015.307     -14015.307      277.30521      277.30521      47850.992      47850.992     -1001.5507     -1001.5507    
Loop time of 50.5998 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.708 ns/day, 14.055 hours/ns, 19.763 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.446     | 50.446     | 50.446     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021487   | 0.021487   | 0.021487   |   0.0 |  0.04
Output  | 6.9241e-05 | 6.9241e-05 | 6.9241e-05 |   0.0 |  0.00
Modify  | 0.12128    | 0.12128    | 0.12128    |   0.0 |  0.24
Other   |            | 0.01045    |            |       |  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:       343774 ave      343774 max      343774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343774
Ave neighs/atom = 85.9435
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 = 273.16372682893, Press = 4.68609656586533
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13871.964     -13871.964     -14015.307     -14015.307      277.30521      277.30521      47850.992      47850.992     -1001.5507     -1001.5507    
     22000  -13876.516     -13876.516     -14017.76      -14017.76       273.24586      273.24586      47800.196      47800.196      825.6167       825.6167     
Loop time of 50.6217 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.707 ns/day, 14.062 hours/ns, 19.754 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.468     | 50.468     | 50.468     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021613   | 0.021613   | 0.021613   |   0.0 |  0.04
Output  | 6.895e-05  | 6.895e-05  | 6.895e-05  |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  0.24
Other   |            | 0.01041    |            |       |  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:       343722 ave      343722 max      343722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343722
Ave neighs/atom = 85.9305
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 = 273.259122556818, Press = 1.88667896576958
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13876.516     -13876.516     -14017.76      -14017.76       273.24586      273.24586      47800.196      47800.196      825.6167       825.6167     
     23000  -13873.503     -13873.503     -14016.937     -14016.937      277.48202      277.48202      47826.021      47826.021     -251.21491     -251.21491    
Loop time of 50.5559 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.709 ns/day, 14.043 hours/ns, 19.780 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.402     | 50.402     | 50.402     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021576   | 0.021576   | 0.021576   |   0.0 |  0.04
Output  | 6.2768e-05 | 6.2768e-05 | 6.2768e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.24
Other   |            | 0.01041    |            |       |  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:       343758 ave      343758 max      343758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343758
Ave neighs/atom = 85.9395
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 = 273.263061460641, Press = 2.97184133070591
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13873.503     -13873.503     -14016.937     -14016.937      277.48202      277.48202      47826.021      47826.021     -251.21491     -251.21491    
     24000  -13877.371     -13877.371     -14017.23      -14017.23       270.56792      270.56792      47782.052      47782.052      1774.0308      1774.0308    
Loop time of 50.5752 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.708 ns/day, 14.049 hours/ns, 19.773 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.422     | 50.422     | 50.422     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021641   | 0.021641   | 0.021641   |   0.0 |  0.04
Output  | 3.8702e-05 | 3.8702e-05 | 3.8702e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.24
Other   |            | 0.0104     |            |       |  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:       343668 ave      343668 max      343668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343668
Ave neighs/atom = 85.917
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 = 273.311202515381, Press = 5.42333786182404
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13877.371     -13877.371     -14017.23      -14017.23       270.56792      270.56792      47782.052      47782.052      1774.0308      1774.0308    
     25000  -13874.752     -13874.752     -14017.115     -14017.115      275.41058      275.41058      47835.203      47835.203     -732.05621     -732.05621    
Loop time of 50.5546 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.709 ns/day, 14.043 hours/ns, 19.781 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.401     | 50.401     | 50.401     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021501   | 0.021501   | 0.021501   |   0.0 |  0.04
Output  | 7.7906e-05 | 7.7906e-05 | 7.7906e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.24
Other   |            | 0.01043    |            |       |  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:       343730 ave      343730 max      343730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343730
Ave neighs/atom = 85.9325
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 = 273.339454382148, Press = 4.42222122373397
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13874.752     -13874.752     -14017.115     -14017.115      275.41058      275.41058      47835.203      47835.203     -732.05621     -732.05621    
     26000  -13876.711     -13876.711     -14017.637     -14017.637      272.63172      272.63172      47854.995      47854.995     -1679.4094     -1679.4094    
Loop time of 50.5671 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.709 ns/day, 14.046 hours/ns, 19.776 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.414     | 50.414     | 50.414     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021631   | 0.021631   | 0.021631   |   0.0 |  0.04
Output  | 7.5191e-05 | 7.5191e-05 | 7.5191e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.24
Other   |            | 0.01046    |            |       |  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:       343714 ave      343714 max      343714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343714
Ave neighs/atom = 85.9285
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 = 273.398108618236, Press = 0.667538943108419
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13876.711     -13876.711     -14017.637     -14017.637      272.63172      272.63172      47854.995      47854.995     -1679.4094     -1679.4094    
     27000  -13873.134     -13873.134     -14015.495     -14015.495      275.40706      275.40706      47790.053      47790.053      1668.3921      1668.3921    
Loop time of 50.5673 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.709 ns/day, 14.046 hours/ns, 19.776 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.414     | 50.414     | 50.414     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021639   | 0.021639   | 0.021639   |   0.0 |  0.04
Output  | 6.3229e-05 | 6.3229e-05 | 6.3229e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.24
Other   |            | 0.01046    |            |       |  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:       343734 ave      343734 max      343734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343734
Ave neighs/atom = 85.9335
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 = 273.388030612604, Press = 2.14564528961892
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13873.134     -13873.134     -14015.495     -14015.495      275.40706      275.40706      47790.053      47790.053      1668.3921      1668.3921    
     28000  -13876.988     -13876.988     -14018.777     -14018.777      274.30025      274.30025      47831.085      47831.085     -719.32383     -719.32383    
Loop time of 50.6176 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.707 ns/day, 14.060 hours/ns, 19.756 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.464     | 50.464     | 50.464     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021548   | 0.021548   | 0.021548   |   0.0 |  0.04
Output  | 7.0442e-05 | 7.0442e-05 | 7.0442e-05 |   0.0 |  0.00
Modify  | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.24
Other   |            | 0.01044    |            |       |  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:       343838 ave      343838 max      343838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343838
Ave neighs/atom = 85.9595
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 = 273.338209259137, Press = 2.46487891123403
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13876.988     -13876.988     -14018.777     -14018.777      274.30025      274.30025      47831.085      47831.085     -719.32383     -719.32383    
     29000  -13877.591     -13877.591     -14017.763     -14017.763      271.17134      271.17134      47839.171      47839.171     -986.36555     -986.36555    
Loop time of 50.641 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.706 ns/day, 14.067 hours/ns, 19.747 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.487     | 50.487     | 50.487     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021844   | 0.021844   | 0.021844   |   0.0 |  0.04
Output  | 6.6124e-05 | 6.6124e-05 | 6.6124e-05 |   0.0 |  0.00
Modify  | 0.12147    | 0.12147    | 0.12147    |   0.0 |  0.24
Other   |            | 0.01044    |            |       |  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:       343728 ave      343728 max      343728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343728
Ave neighs/atom = 85.932
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 = 273.322452568562, Press = 0.996050330771183
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 = 12 12 12
  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.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13877.591     -13877.591     -14017.763     -14017.763      271.17134      271.17134      47839.171      47839.171     -986.36555     -986.36555    
     30000  -13871.889     -13871.889     -14015.521     -14015.521      277.86638      277.86638      47857.427      47857.427     -1379.55       -1379.55      
Loop time of 50.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.707 ns/day, 14.063 hours/ns, 19.752 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.474     | 50.474     | 50.474     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021572   | 0.021572   | 0.021572   |   0.0 |  0.04
Output  | 4.7068e-05 | 4.7068e-05 | 4.7068e-05 |   0.0 |  0.00
Modify  | 0.12149    | 0.12149    | 0.12149    |   0.0 |  0.24
Other   |            | 0.01041    |            |       |  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:       343754 ave      343754 max      343754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343754
Ave neighs/atom = 85.9385
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
47820.0405661231

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0