# 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 63.546*${_u_mass}
variable mass_converted equal 63.546*1

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WangOhLee_2020_CuMo__MO_380272712420_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

# 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_380272712420_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14018.806     -14018.806     -14160         -14160          273.15         273.15         47175.631      47175.631      3196.8378      3196.8378    
      1000  -13870.076     -13870.076     -14014.445     -14014.445      279.29183      279.29183      47934.911      47934.911     -1401.2829     -1401.2829    
Loop time of 100.555 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.859 ns/day, 27.932 hours/ns, 9.945 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    | 100.38     | 100.38     | 100.38     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031978   | 0.031978   | 0.031978   |   0.0 |  0.03
Output  | 0.0001904  | 0.0001904  | 0.0001904  |   0.0 |  0.00
Modify  | 0.12926    | 0.12926    | 0.12926    |   0.0 |  0.13
Other   |            | 0.01585    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       704000 ave      704000 max      704000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704000
Ave neighs/atom = 176
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13870.076     -13870.076     -14014.445     -14014.445      279.29183      279.29183      47934.911      47934.911     -1401.2829     -1401.2829    
      2000  -13879.752     -13879.752     -14022.361     -14022.361      275.88555      275.88555      47875.069      47875.069     -480.35143     -480.35143    
Loop time of 105.499 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.305 hours/ns, 9.479 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    | 105.33     | 105.33     | 105.33     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030413   | 0.030413   | 0.030413   |   0.0 |  0.03
Output  | 9.8034e-05 | 9.8034e-05 | 9.8034e-05 |   0.0 |  0.00
Modify  | 0.12297    | 0.12297    | 0.12297    |   0.0 |  0.12
Other   |            | 0.01424    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715588 ave      715588 max      715588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715588
Ave neighs/atom = 178.897
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13879.752     -13879.752     -14022.361     -14022.361      275.88555      275.88555      47875.069      47875.069     -480.35143     -480.35143    
      3000  -13877.049     -13877.049     -14021.487     -14021.487      279.42415      279.42415      47890.152      47890.152     -639.83307     -639.83307    
Loop time of 105.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.327 hours/ns, 9.472 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    | 105.41     | 105.41     | 105.41     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030611   | 0.030611   | 0.030611   |   0.0 |  0.03
Output  | 0.000107   | 0.000107   | 0.000107   |   0.0 |  0.00
Modify  | 0.1234     | 0.1234     | 0.1234     |   0.0 |  0.12
Other   |            | 0.014      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715998 ave      715998 max      715998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715998
Ave neighs/atom = 178.9995
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13877.049     -13877.049     -14021.487     -14021.487      279.42415      279.42415      47890.152      47890.152     -639.83307     -639.83307    
      4000  -13877.12      -13877.12      -14018.007     -14018.007      272.55582      272.55582      47905.817      47905.817     -856.44901     -856.44901    
Loop time of 105.559 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.322 hours/ns, 9.473 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    | 105.39     | 105.39     | 105.39     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030665   | 0.030665   | 0.030665   |   0.0 |  0.03
Output  | 9.5359e-05 | 9.5359e-05 | 9.5359e-05 |   0.0 |  0.00
Modify  | 0.12311    | 0.12311    | 0.12311    |   0.0 |  0.12
Other   |            | 0.01411    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715138 ave      715138 max      715138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715138
Ave neighs/atom = 178.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 = 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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13877.12      -13877.12      -14018.007     -14018.007      272.55582      272.55582      47905.817      47905.817     -856.44901     -856.44901    
      5000  -13880.22      -13880.22      -14017.363     -14017.363      265.31181      265.31181      47860.951      47860.951      513.55773      513.55773    
Loop time of 105.675 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.354 hours/ns, 9.463 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    | 105.51     | 105.51     | 105.51     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030557   | 0.030557   | 0.030557   |   0.0 |  0.03
Output  | 7.0663e-05 | 7.0663e-05 | 7.0663e-05 |   0.0 |  0.00
Modify  | 0.1239     | 0.1239     | 0.1239     |   0.0 |  0.12
Other   |            | 0.01387    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715684 ave      715684 max      715684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715684
Ave neighs/atom = 178.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 = 274.452431316918, Press = 727.423709550287
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13880.22      -13880.22      -14017.363     -14017.363      265.31181      265.31181      47860.951      47860.951      513.55773      513.55773    
      6000  -13874.143     -13874.143     -14020.344     -14020.344      282.83644      282.83644      47823.358      47823.358      1491.2044      1491.2044    
Loop time of 105.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.323 hours/ns, 9.473 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    | 105.39     | 105.39     | 105.39     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030437   | 0.030437   | 0.030437   |   0.0 |  0.03
Output  | 6.922e-05  | 6.922e-05  | 6.922e-05  |   0.0 |  0.00
Modify  | 0.12837    | 0.12837    | 0.12837    |   0.0 |  0.12
Other   |            | 0.01397    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715910 ave      715910 max      715910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715910
Ave neighs/atom = 178.9775
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.610071930921, Press = 17.7903874724737
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13874.143     -13874.143     -14020.344     -14020.344      282.83644      282.83644      47823.358      47823.358      1491.2044      1491.2044    
      7000  -13880.514     -13880.514     -14019.502     -14019.502      268.88252      268.88252      47908.507      47908.507     -1036.1855     -1036.1855    
Loop time of 105.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.817 ns/day, 29.370 hours/ns, 9.458 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    | 105.56     | 105.56     | 105.56     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030639   | 0.030639   | 0.030639   |   0.0 |  0.03
Output  | 6.9731e-05 | 6.9731e-05 | 6.9731e-05 |   0.0 |  0.00
Modify  | 0.12824    | 0.12824    | 0.12824    |   0.0 |  0.12
Other   |            | 0.01411    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716074 ave      716074 max      716074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716074
Ave neighs/atom = 179.0185
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.012114574218, Press = -4.48326740266959
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13880.514     -13880.514     -14019.502     -14019.502      268.88252      268.88252      47908.507      47908.507     -1036.1855     -1036.1855    
      8000  -13879.31      -13879.31      -14018.24      -14018.24       268.76918      268.76918      47900.154      47900.154     -711.71961     -711.71961    
Loop time of 105.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.285 hours/ns, 9.485 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    | 105.25     | 105.25     | 105.25     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030716   | 0.030716   | 0.030716   |   0.0 |  0.03
Output  | 7.2727e-05 | 7.2727e-05 | 7.2727e-05 |   0.0 |  0.00
Modify  | 0.12804    | 0.12804    | 0.12804    |   0.0 |  0.12
Other   |            | 0.0139     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715340 ave      715340 max      715340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715340
Ave neighs/atom = 178.835
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.088072582238, Press = 19.9536951061243
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13879.31      -13879.31      -14018.24      -14018.24       268.76918      268.76918      47900.154      47900.154     -711.71961     -711.71961    
      9000  -13873.264     -13873.264     -14014.598     -14014.598      273.4189       273.4189       47847.43       47847.43       1351.3936      1351.3936    
Loop time of 105.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.248 hours/ns, 9.497 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    | 105.12     | 105.12     | 105.12     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030834   | 0.030834   | 0.030834   |   0.0 |  0.03
Output  | 6.7467e-05 | 6.7467e-05 | 6.7467e-05 |   0.0 |  0.00
Modify  | 0.12779    | 0.12779    | 0.12779    |   0.0 |  0.12
Other   |            | 0.01384    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715540 ave      715540 max      715540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715540
Ave neighs/atom = 178.885
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.383463840526, Press = 12.2281214645665
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13873.264     -13873.264     -14014.598     -14014.598      273.4189       273.4189       47847.43       47847.43       1351.3936      1351.3936    
     10000  -13875.848     -13875.848     -14016.169     -14016.169      271.46097      271.46097      47872.004      47872.004      394.4301       394.4301     
Loop time of 105.585 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.329 hours/ns, 9.471 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    | 105.41     | 105.41     | 105.41     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030718   | 0.030718   | 0.030718   |   0.0 |  0.03
Output  | 7.6473e-05 | 7.6473e-05 | 7.6473e-05 |   0.0 |  0.00
Modify  | 0.12787    | 0.12787    | 0.12787    |   0.0 |  0.12
Other   |            | 0.01391    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716292 ave      716292 max      716292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716292
Ave neighs/atom = 179.073
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.298219873139, Press = 4.11258344711755
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13875.848     -13875.848     -14016.169     -14016.169      271.46097      271.46097      47872.004      47872.004      394.4301       394.4301     
     11000  -13880.74      -13880.74      -14018.7       -14018.7        266.89321      266.89321      47903.178      47903.178     -896.68962     -896.68962    
Loop time of 105.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.327 hours/ns, 9.472 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    | 105.4      | 105.4      | 105.4      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030602   | 0.030602   | 0.030602   |   0.0 |  0.03
Output  | 7.6193e-05 | 7.6193e-05 | 7.6193e-05 |   0.0 |  0.00
Modify  | 0.12763    | 0.12763    | 0.12763    |   0.0 |  0.12
Other   |            | 0.01393    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715894 ave      715894 max      715894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715894
Ave neighs/atom = 178.9735
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.181712788082, Press = 2.01454785885856
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13880.74      -13880.74      -14018.7       -14018.7        266.89321      266.89321      47903.178      47903.178     -896.68962     -896.68962    
     12000  -13879.029     -13879.029     -14019.863     -14019.863      272.45373      272.45373      47887.829      47887.829     -429.5866      -429.5866     
Loop time of 105.432 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.287 hours/ns, 9.485 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    | 105.26     | 105.26     | 105.26     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030713   | 0.030713   | 0.030713   |   0.0 |  0.03
Output  | 7.2756e-05 | 7.2756e-05 | 7.2756e-05 |   0.0 |  0.00
Modify  | 0.12805    | 0.12805    | 0.12805    |   0.0 |  0.12
Other   |            | 0.01401    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715402 ave      715402 max      715402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715402
Ave neighs/atom = 178.8505
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.921830545466, Press = 11.461829132487
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13879.029     -13879.029     -14019.863     -14019.863      272.45373      272.45373      47887.829      47887.829     -429.5866      -429.5866     
     13000  -13879.086     -13879.086     -14020.59      -14020.59       273.74988      273.74988      47798.834      47798.834      2059.8151      2059.8151    
Loop time of 105.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.327 hours/ns, 9.472 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    | 105.4      | 105.4      | 105.4      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030662   | 0.030662   | 0.030662   |   0.0 |  0.03
Output  | 6.9711e-05 | 6.9711e-05 | 6.9711e-05 |   0.0 |  0.00
Modify  | 0.12777    | 0.12777    | 0.12777    |   0.0 |  0.12
Other   |            | 0.01396    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715434 ave      715434 max      715434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715434
Ave neighs/atom = 178.8585
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.939851481014, Press = 2.55621997485768
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13879.086     -13879.086     -14020.59      -14020.59       273.74988      273.74988      47798.834      47798.834      2059.8151      2059.8151    
     14000  -13872.129     -13872.129     -14013.699     -14013.699      273.8767       273.8767       47913.973      47913.973     -537.88402     -537.88402    
Loop time of 105.49 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.303 hours/ns, 9.480 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    | 105.32     | 105.32     | 105.32     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030701   | 0.030701   | 0.030701   |   0.0 |  0.03
Output  | 0.00013735 | 0.00013735 | 0.00013735 |   0.0 |  0.00
Modify  | 0.12774    | 0.12774    | 0.12774    |   0.0 |  0.12
Other   |            | 0.01395    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716398 ave      716398 max      716398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716398
Ave neighs/atom = 179.0995
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.054101750948, Press = 0.994585907697694
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13872.129     -13872.129     -14013.699     -14013.699      273.8767       273.8767       47913.973      47913.973     -537.88402     -537.88402    
     15000  -13879.075     -13879.075     -14019.717     -14019.717      272.0821       272.0821       47872.848      47872.848     -91.815598     -91.815598    
Loop time of 105.669 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.353 hours/ns, 9.463 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    | 105.5      | 105.5      | 105.5      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030719   | 0.030719   | 0.030719   |   0.0 |  0.03
Output  | 7.0392e-05 | 7.0392e-05 | 7.0392e-05 |   0.0 |  0.00
Modify  | 0.12795    | 0.12795    | 0.12795    |   0.0 |  0.12
Other   |            | 0.01391    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715612 ave      715612 max      715612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715612
Ave neighs/atom = 178.903
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.187728218033, Press = 3.89620082136632
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13879.075     -13879.075     -14019.717     -14019.717      272.0821       272.0821       47872.848      47872.848     -91.815598     -91.815598    
     16000  -13882.562     -13882.562     -14022.519     -14022.519      270.75541      270.75541      47843.52       47843.52       493.39623      493.39623    
Loop time of 105.347 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.263 hours/ns, 9.492 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    | 105.17     | 105.17     | 105.17     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030651   | 0.030651   | 0.030651   |   0.0 |  0.03
Output  | 6.7006e-05 | 6.7006e-05 | 6.7006e-05 |   0.0 |  0.00
Modify  | 0.128      | 0.128      | 0.128      |   0.0 |  0.12
Other   |            | 0.01395    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715812 ave      715812 max      715812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715812
Ave neighs/atom = 178.953
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.15870855014, Press = 3.81366841057444
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13882.562     -13882.562     -14022.519     -14022.519      270.75541      270.75541      47843.52       47843.52       493.39623      493.39623    
     17000  -13874.821     -13874.821     -14016.163     -14016.163      273.4348       273.4348       47860.939      47860.939      746.48481      746.48481    
Loop time of 105.511 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.309 hours/ns, 9.478 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    | 105.34     | 105.34     | 105.34     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030887   | 0.030887   | 0.030887   |   0.0 |  0.03
Output  | 6.6454e-05 | 6.6454e-05 | 6.6454e-05 |   0.0 |  0.00
Modify  | 0.1279     | 0.1279     | 0.1279     |   0.0 |  0.12
Other   |            | 0.01401    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715896 ave      715896 max      715896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715896
Ave neighs/atom = 178.974
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.066518956997, Press = 1.53399089145463
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13874.821     -13874.821     -14016.163     -14016.163      273.4348       273.4348       47860.939      47860.939      746.48481      746.48481    
     18000  -13878.752     -13878.752     -14019.411     -14019.411      272.11377      272.11377      47909.065      47909.065     -1116.3095     -1116.3095    
Loop time of 105.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.310 hours/ns, 9.477 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    | 105.34     | 105.34     | 105.34     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030644   | 0.030644   | 0.030644   |   0.0 |  0.03
Output  | 7.0923e-05 | 7.0923e-05 | 7.0923e-05 |   0.0 |  0.00
Modify  | 0.12766    | 0.12766    | 0.12766    |   0.0 |  0.12
Other   |            | 0.01398    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715988 ave      715988 max      715988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715988
Ave neighs/atom = 178.997
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.19719649312, Press = 0.231362878164237
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13878.752     -13878.752     -14019.411     -14019.411      272.11377      272.11377      47909.065      47909.065     -1116.3095     -1116.3095    
     19000  -13872.66      -13872.66      -14012.881     -14012.881      271.26688      271.26688      47911.034      47911.034     -416.02361     -416.02361    
Loop time of 105.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.238 hours/ns, 9.501 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    | 105.09     | 105.09     | 105.09     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030582   | 0.030582   | 0.030582   |   0.0 |  0.03
Output  | 6.923e-05  | 6.923e-05  | 6.923e-05  |   0.0 |  0.00
Modify  | 0.12789    | 0.12789    | 0.12789    |   0.0 |  0.12
Other   |            | 0.01392    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715418 ave      715418 max      715418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715418
Ave neighs/atom = 178.8545
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.285576032823, Press = 4.09286792890077
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13872.66      -13872.66      -14012.881     -14012.881      271.26688      271.26688      47911.034      47911.034     -416.02361     -416.02361    
     20000  -13875.901     -13875.901     -14019.484     -14019.484      277.77053      277.77053      47819.843      47819.843      1578.2996      1578.2996    
Loop time of 105.566 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.324 hours/ns, 9.473 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    | 105.39     | 105.39     | 105.39     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030748   | 0.030748   | 0.030748   |   0.0 |  0.03
Output  | 6.891e-05  | 6.891e-05  | 6.891e-05  |   0.0 |  0.00
Modify  | 0.12828    | 0.12828    | 0.12828    |   0.0 |  0.12
Other   |            | 0.01401    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715748 ave      715748 max      715748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715748
Ave neighs/atom = 178.937
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.255452463406, Press = 1.98686382453513
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13875.901     -13875.901     -14019.484     -14019.484      277.77053      277.77053      47819.843      47819.843      1578.2996      1578.2996    
     21000  -13882.143     -13882.143     -14021.998     -14021.998      270.56017      270.56017      47877.3        47877.3       -357.4179      -357.4179     
Loop time of 105.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.342 hours/ns, 9.467 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    | 105.46     | 105.46     | 105.46     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03075    | 0.03075    | 0.03075    |   0.0 |  0.03
Output  | 7.2536e-05 | 7.2536e-05 | 7.2536e-05 |   0.0 |  0.00
Modify  | 0.12794    | 0.12794    | 0.12794    |   0.0 |  0.12
Other   |            | 0.01395    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716308 ave      716308 max      716308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716308
Ave neighs/atom = 179.077
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.195560700592, Press = -1.99501037326464
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13882.143     -13882.143     -14021.998     -14021.998      270.56017      270.56017      47877.3        47877.3       -357.4179      -357.4179     
     22000  -13876.577     -13876.577     -14017.583     -14017.583      272.7841       272.7841       47962.234      47962.234     -2396.2651     -2396.2651    
Loop time of 105.353 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.265 hours/ns, 9.492 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    | 105.18     | 105.18     | 105.18     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030525   | 0.030525   | 0.030525   |   0.0 |  0.03
Output  | 5.5695e-05 | 5.5695e-05 | 5.5695e-05 |   0.0 |  0.00
Modify  | 0.12766    | 0.12766    | 0.12766    |   0.0 |  0.12
Other   |            | 0.01399    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715430 ave      715430 max      715430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715430
Ave neighs/atom = 178.8575
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.137707909699, Press = 3.3951377235468
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13876.577     -13876.577     -14017.583     -14017.583      272.7841       272.7841       47962.234      47962.234     -2396.2651     -2396.2651    
     23000  -13873.497     -13873.497     -14014.553     -14014.553      272.8826       272.8826       47850.035      47850.035      1262.4852      1262.4852    
Loop time of 105.3 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.250 hours/ns, 9.497 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    | 105.13     | 105.13     | 105.13     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030878   | 0.030878   | 0.030878   |   0.0 |  0.03
Output  | 6.5803e-05 | 6.5803e-05 | 6.5803e-05 |   0.0 |  0.00
Modify  | 0.128      | 0.128      | 0.128      |   0.0 |  0.12
Other   |            | 0.01409    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714754 ave      714754 max      714754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714754
Ave neighs/atom = 178.6885
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.114263067128, Press = 3.4968875023132
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13873.497     -13873.497     -14014.553     -14014.553      272.8826       272.8826       47850.035      47850.035      1262.4852      1262.4852    
     24000  -13877.793     -13877.793     -14019.559     -14019.559      274.25606      274.25606      47863.483      47863.483      326.41078      326.41078    
Loop time of 105.527 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.313 hours/ns, 9.476 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    | 105.36     | 105.36     | 105.36     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030348   | 0.030348   | 0.030348   |   0.0 |  0.03
Output  | 6.382e-05  | 6.382e-05  | 6.382e-05  |   0.0 |  0.00
Modify  | 0.12656    | 0.12656    | 0.12656    |   0.0 |  0.12
Other   |            | 0.01331    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715866 ave      715866 max      715866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715866
Ave neighs/atom = 178.9665
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.118784885929, Press = 0.751558016370209
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13877.793     -13877.793     -14019.559     -14019.559      274.25606      274.25606      47863.483      47863.483      326.41078      326.41078    
     25000  -13876.402     -13876.402     -14015.783     -14015.783      269.64023      269.64023      47911.388      47911.388     -667.30744     -667.30744    
Loop time of 105.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.335 hours/ns, 9.469 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    | 105.44     | 105.44     | 105.44     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030212   | 0.030212   | 0.030212   |   0.0 |  0.03
Output  | 6.0744e-05 | 6.0744e-05 | 6.0744e-05 |   0.0 |  0.00
Modify  | 0.12476    | 0.12476    | 0.12476    |   0.0 |  0.12
Other   |            | 0.01265    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715792 ave      715792 max      715792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715792
Ave neighs/atom = 178.948
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.115329818373, Press = 1.24006279663216
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13876.402     -13876.402     -14015.783     -14015.783      269.64023      269.64023      47911.388      47911.388     -667.30744     -667.30744    
     26000  -13880.545     -13880.545     -14018.878     -14018.878      267.61443      267.61443      47870.051      47870.051      193.06964      193.06964    
Loop time of 105.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.224 hours/ns, 9.505 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    | 105.04     | 105.04     | 105.04     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030287   | 0.030287   | 0.030287   |   0.0 |  0.03
Output  | 5.9752e-05 | 5.9752e-05 | 5.9752e-05 |   0.0 |  0.00
Modify  | 0.12491    | 0.12491    | 0.12491    |   0.0 |  0.12
Other   |            | 0.01264    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715272 ave      715272 max      715272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715272
Ave neighs/atom = 178.818
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.123661404109, Press = 3.22889570835963
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13880.545     -13880.545     -14018.878     -14018.878      267.61443      267.61443      47870.051      47870.051      193.06964      193.06964    
     27000  -13875.566     -13875.566     -14015.607     -14015.607      270.91951      270.91951      47774.923      47774.923      3271.0787      3271.0787    
Loop time of 105.185 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.218 hours/ns, 9.507 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    | 105.02     | 105.02     | 105.02     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030279   | 0.030279   | 0.030279   |   0.0 |  0.03
Output  | 6.6375e-05 | 6.6375e-05 | 6.6375e-05 |   0.0 |  0.00
Modify  | 0.12495    | 0.12495    | 0.12495    |   0.0 |  0.12
Other   |            | 0.01261    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715430 ave      715430 max      715430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715430
Ave neighs/atom = 178.8575
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.07850590775, Press = 1.187234636398
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13875.566     -13875.566     -14015.607     -14015.607      270.91951      270.91951      47774.923      47774.923      3271.0787      3271.0787    
     28000  -13881.963     -13881.963     -14020.071     -14020.071      267.17972      267.17972      47896.989      47896.989     -713.38268     -713.38268    
Loop time of 105.272 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.242 hours/ns, 9.499 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    | 105.1      | 105.1      | 105.1      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03028    | 0.03028    | 0.03028    |   0.0 |  0.03
Output  | 6.5603e-05 | 6.5603e-05 | 6.5603e-05 |   0.0 |  0.00
Modify  | 0.12486    | 0.12486    | 0.12486    |   0.0 |  0.12
Other   |            | 0.01273    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716974 ave      716974 max      716974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716974
Ave neighs/atom = 179.2435
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.028917909236, Press = -1.08947232844284
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13881.963     -13881.963     -14020.071     -14020.071      267.17972      267.17972      47896.989      47896.989     -713.38268     -713.38268    
     29000  -13876.696     -13876.696     -14017.772     -14017.772      272.92075      272.92075      47905.997      47905.997     -780.74688     -780.74688    
Loop time of 105.36 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.267 hours/ns, 9.491 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    | 105.19     | 105.19     | 105.19     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030408   | 0.030408   | 0.030408   |   0.0 |  0.03
Output  | 6.9029e-05 | 6.9029e-05 | 6.9029e-05 |   0.0 |  0.00
Modify  | 0.12486    | 0.12486    | 0.12486    |   0.0 |  0.12
Other   |            | 0.0127     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715012 ave      715012 max      715012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715012
Ave neighs/atom = 178.753
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.96623593974, Press = 2.45099387626304
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13876.696     -13876.696     -14017.772     -14017.772      272.92075      272.92075      47905.997      47905.997     -780.74688     -780.74688    
     30000  -13881.007     -13881.007     -14020.695     -14020.695      270.23675      270.23675      47833.951      47833.951      963.37553      963.37553    
Loop time of 105.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.243 hours/ns, 9.499 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    | 105.11     | 105.11     | 105.11     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030322   | 0.030322   | 0.030322   |   0.0 |  0.03
Output  | 6.5372e-05 | 6.5372e-05 | 6.5372e-05 |   0.0 |  0.00
Modify  | 0.125      | 0.125      | 0.125      |   0.0 |  0.12
Other   |            | 0.01271    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715366 ave      715366 max      715366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715366
Ave neighs/atom = 178.8415
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.933835539586, Press = 1.70498299798375
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13881.007     -13881.007     -14020.695     -14020.695      270.23675      270.23675      47833.951      47833.951      963.37553      963.37553    
     31000  -13874.68      -13874.68      -14014.98      -14014.98       271.4194       271.4194       47868.009      47868.009      693.41024      693.41024    
Loop time of 105.327 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.258 hours/ns, 9.494 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    | 105.16     | 105.16     | 105.16     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03038    | 0.03038    | 0.03038    |   0.0 |  0.03
Output  | 6.6865e-05 | 6.6865e-05 | 6.6865e-05 |   0.0 |  0.00
Modify  | 0.1248     | 0.1248     | 0.1248     |   0.0 |  0.12
Other   |            | 0.01275    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715728 ave      715728 max      715728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715728
Ave neighs/atom = 178.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 = 272.938898061849, Press = 0.886901030105942
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13874.68      -13874.68      -14014.98      -14014.98       271.4194       271.4194       47868.009      47868.009      693.41024      693.41024    
     32000  -13878.825     -13878.825     -14017.27      -14017.27       267.82997      267.82997      47907.501      47907.501     -822.58043     -822.58043    
Loop time of 105.33 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.258 hours/ns, 9.494 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    | 105.16     | 105.16     | 105.16     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030448   | 0.030448   | 0.030448   |   0.0 |  0.03
Output  | 7.0552e-05 | 7.0552e-05 | 7.0552e-05 |   0.0 |  0.00
Modify  | 0.12498    | 0.12498    | 0.12498    |   0.0 |  0.12
Other   |            | 0.01268    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715970 ave      715970 max      715970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715970
Ave neighs/atom = 178.9925
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
47875.5513794358

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0