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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 4.072935052216053*${_u_distance}
variable latticeconst_converted equal 4.072935052216053*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.07293505221605
Lattice spacing in x,y,z = 4.0729351 4.0729351 4.0729351
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.729351 40.729351 40.729351)
  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 (40.729351 40.729351 40.729351)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Ag

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

kim interactions Ag
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KangSaLee_2009_ZrAgCu__MO_813575892799_002
pair_coeff * * Ag
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 107.8682

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 67565.1047480748 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_813575892799_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11258.806     -11258.806     -11400         -11400          273.15         273.15         67565.105      67565.105      2232.0959      2232.0959    
      1000  -11109.176     -11109.176     -11246.395     -11246.395      265.45855      265.45855      68742.552      68742.552      965.96585      965.96585    
Loop time of 41.9618 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.059 ns/day, 11.656 hours/ns, 23.831 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    | 41.81      | 41.81      | 41.81      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022118   | 0.022118   | 0.022118   |   0.0 |  0.05
Output  | 0.000161   | 0.000161   | 0.000161   |   0.0 |  0.00
Modify  | 0.1188     | 0.1188     | 0.1188     |   0.0 |  0.28
Other   |            | 0.01111    |            |       |  0.03

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:       312000 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11109.176     -11109.176     -11246.395     -11246.395      265.45855      265.45855      68742.552      68742.552      965.96585      965.96585    
      2000  -11122.559     -11122.559     -11261.661     -11261.661      269.10265      269.10265      68613.269      68613.269      1399.1015      1399.1015    
Loop time of 46.8216 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.845 ns/day, 13.006 hours/ns, 21.358 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.671     | 46.671     | 46.671     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021999   | 0.021999   | 0.021999   |   0.0 |  0.05
Output  | 6.419e-05  | 6.419e-05  | 6.419e-05  |   0.0 |  0.00
Modify  | 0.11785    | 0.11785    | 0.11785    |   0.0 |  0.25
Other   |            | 0.01066    |            |       |  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:       319002 ave      319002 max      319002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 319002
Ave neighs/atom = 79.7505
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11122.559     -11122.559     -11261.661     -11261.661      269.10265      269.10265      68613.269      68613.269      1399.1015      1399.1015    
      3000  -11115.758     -11115.758     -11262.028     -11262.028      282.96874      282.96874      68697.665      68697.665      154.82924      154.82924    
Loop time of 47.0142 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.838 ns/day, 13.059 hours/ns, 21.270 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.864     | 46.864     | 46.864     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021909   | 0.021909   | 0.021909   |   0.0 |  0.05
Output  | 4.4845e-05 | 4.4845e-05 | 4.4845e-05 |   0.0 |  0.00
Modify  | 0.11771    | 0.11771    | 0.11771    |   0.0 |  0.25
Other   |            | 0.01064    |            |       |  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:       318880 ave      318880 max      318880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318880
Ave neighs/atom = 79.72
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11115.758     -11115.758     -11262.028     -11262.028      282.96874      282.96874      68697.665      68697.665      154.82924      154.82924    
      4000  -11116.993     -11116.993     -11259.089     -11259.089      274.8931       274.8931       68735.838      68735.838     -243.93511     -243.93511    
Loop time of 47.0265 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.837 ns/day, 13.063 hours/ns, 21.265 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.876     | 46.876     | 46.876     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021867   | 0.021867   | 0.021867   |   0.0 |  0.05
Output  | 6.4502e-05 | 6.4502e-05 | 6.4502e-05 |   0.0 |  0.00
Modify  | 0.11754    | 0.11754    | 0.11754    |   0.0 |  0.25
Other   |            | 0.01063    |            |       |  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:       318588 ave      318588 max      318588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318588
Ave neighs/atom = 79.647
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11116.993     -11116.993     -11259.089     -11259.089      274.8931       274.8931       68735.838      68735.838     -243.93511     -243.93511    
      5000  -11120.796     -11120.796     -11259.673     -11259.673      268.6664       268.6664       68732.776      68732.776     -375.54712     -375.54712    
Loop time of 47.0267 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.837 ns/day, 13.063 hours/ns, 21.265 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.876     | 46.876     | 46.876     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021884   | 0.021884   | 0.021884   |   0.0 |  0.05
Output  | 4.5566e-05 | 4.5566e-05 | 4.5566e-05 |   0.0 |  0.00
Modify  | 0.11808    | 0.11808    | 0.11808    |   0.0 |  0.25
Other   |            | 0.01066    |            |       |  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:       318666 ave      318666 max      318666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318666
Ave neighs/atom = 79.6665
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.079185468055, Press = 95.6534779233868
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11120.796     -11120.796     -11259.673     -11259.673      268.6664       268.6664       68732.776      68732.776     -375.54712     -375.54712    
      6000  -11118.896     -11118.896     -11256.354     -11256.354      265.92224      265.92224      68799.72       68799.72      -1045.4796     -1045.4796    
Loop time of 47.1329 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.833 ns/day, 13.092 hours/ns, 21.217 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.979     | 46.979     | 46.979     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022018   | 0.022018   | 0.022018   |   0.0 |  0.05
Output  | 4.788e-05  | 4.788e-05  | 4.788e-05  |   0.0 |  0.00
Modify  | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.26
Other   |            | 0.01068    |            |       |  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:       318718 ave      318718 max      318718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318718
Ave neighs/atom = 79.6795
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.003657486403, Press = 19.912472369122
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11118.896     -11118.896     -11256.354     -11256.354      265.92224      265.92224      68799.72       68799.72      -1045.4796     -1045.4796    
      7000  -11119.793     -11119.793     -11257.783     -11257.783      266.95135      266.95135      68698.665      68698.665      310.81163      310.81163    
Loop time of 47.1645 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.832 ns/day, 13.101 hours/ns, 21.202 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    | 47.011     | 47.011     | 47.011     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021862   | 0.021862   | 0.021862   |   0.0 |  0.05
Output  | 3.1629e-05 | 3.1629e-05 | 3.1629e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.26
Other   |            | 0.01066    |            |       |  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:       318600 ave      318600 max      318600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318600
Ave neighs/atom = 79.65
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.933664211396, Press = 0.241113672484646
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11119.793     -11119.793     -11257.783     -11257.783      266.95135      266.95135      68698.665      68698.665      310.81163      310.81163    
      8000  -11120.962     -11120.962     -11262.759     -11262.759      274.31502      274.31502      68661.904      68661.904      489.54196      489.54196    
Loop time of 47.2181 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.116 hours/ns, 21.178 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    | 47.064     | 47.064     | 47.064     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021964   | 0.021964   | 0.021964   |   0.0 |  0.05
Output  | 4.1689e-05 | 4.1689e-05 | 4.1689e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.26
Other   |            | 0.01068    |            |       |  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:       318860 ave      318860 max      318860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318860
Ave neighs/atom = 79.715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.104878125956, Press = 3.32777579220096
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11120.962     -11120.962     -11262.759     -11262.759      274.31502      274.31502      68661.904      68661.904      489.54196      489.54196    
      9000  -11117.92      -11117.92      -11258.217     -11258.217      271.41284      271.41284      68671.015      68671.015      781.64679      781.64679    
Loop time of 47.1988 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.831 ns/day, 13.111 hours/ns, 21.187 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    | 47.045     | 47.045     | 47.045     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021917   | 0.021917   | 0.021917   |   0.0 |  0.05
Output  | 4.5125e-05 | 4.5125e-05 | 4.5125e-05 |   0.0 |  0.00
Modify  | 0.12153    | 0.12153    | 0.12153    |   0.0 |  0.26
Other   |            | 0.01067    |            |       |  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:       318860 ave      318860 max      318860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318860
Ave neighs/atom = 79.715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.296831963653, Press = 7.40553604639081
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11117.92      -11117.92      -11258.217     -11258.217      271.41284      271.41284      68671.015      68671.015      781.64679      781.64679    
     10000  -11119.157     -11119.157     -11260.606     -11260.606      273.64323      273.64323      68610.988      68610.988      1573.5375      1573.5375    
Loop time of 47.2194 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.116 hours/ns, 21.178 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    | 47.066     | 47.066     | 47.066     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021841   | 0.021841   | 0.021841   |   0.0 |  0.05
Output  | 4.2139e-05 | 4.2139e-05 | 4.2139e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.26
Other   |            | 0.01067    |            |       |  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:       318920 ave      318920 max      318920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318920
Ave neighs/atom = 79.73
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.577478684573, Press = 4.39799258174576
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11119.157     -11119.157     -11260.606     -11260.606      273.64323      273.64323      68610.988      68610.988      1573.5375      1573.5375    
     11000  -11118.307     -11118.307     -11263.184     -11263.184      280.27406      280.27406      68686.612      68686.612      155.00465      155.00465    
Loop time of 47.2438 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.829 ns/day, 13.123 hours/ns, 21.167 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    | 47.09      | 47.09      | 47.09      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021933   | 0.021933   | 0.021933   |   0.0 |  0.05
Output  | 3.9935e-05 | 3.9935e-05 | 3.9935e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.26
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:       318890 ave      318890 max      318890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318890
Ave neighs/atom = 79.7225
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.458206380173, Press = -0.771360622310254
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11118.307     -11118.307     -11263.184     -11263.184      280.27406      280.27406      68686.612      68686.612      155.00465      155.00465    
     12000  -11119.042     -11119.042     -11260.067     -11260.067      272.82356      272.82356      68659.11       68659.11       839.76634      839.76634    
Loop time of 47.204 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.112 hours/ns, 21.185 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    | 47.05      | 47.05      | 47.05      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021912   | 0.021912   | 0.021912   |   0.0 |  0.05
Output  | 3.207e-05  | 3.207e-05  | 3.207e-05  |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.26
Other   |            | 0.01064    |            |       |  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:       318566 ave      318566 max      318566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318566
Ave neighs/atom = 79.6415
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.610621458461, Press = -0.317204393531141
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11119.042     -11119.042     -11260.067     -11260.067      272.82356      272.82356      68659.11       68659.11       839.76634      839.76634    
     13000  -11121.475     -11121.475     -11261.339     -11261.339      270.57624      270.57624      68686.616      68686.616      261.94792      261.94792    
Loop time of 47.1832 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.831 ns/day, 13.106 hours/ns, 21.194 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    | 47.029     | 47.029     | 47.029     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021948   | 0.021948   | 0.021948   |   0.0 |  0.05
Output  | 4.1267e-05 | 4.1267e-05 | 4.1267e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.26
Other   |            | 0.01061    |            |       |  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:       318788 ave      318788 max      318788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318788
Ave neighs/atom = 79.697
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.558221031864, Press = 2.4151517974617
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11121.475     -11121.475     -11261.339     -11261.339      270.57624      270.57624      68686.616      68686.616      261.94792      261.94792    
     14000  -11115.543     -11115.543     -11258.95      -11258.95       277.43061      277.43061      68626.155      68626.155      1481.0117      1481.0117    
Loop time of 47.2122 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.114 hours/ns, 21.181 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    | 47.058     | 47.058     | 47.058     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021845   | 0.021845   | 0.021845   |   0.0 |  0.05
Output  | 7.2717e-05 | 7.2717e-05 | 7.2717e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.26
Other   |            | 0.01066    |            |       |  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:       318800 ave      318800 max      318800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318800
Ave neighs/atom = 79.7
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.510662955817, Press = 4.21948116190064
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11115.543     -11115.543     -11258.95      -11258.95       277.43061      277.43061      68626.155      68626.155      1481.0117      1481.0117    
     15000  -11117.331     -11117.331     -11261.347     -11261.347      278.61         278.61         68626.951      68626.951      1250.0276      1250.0276    
Loop time of 47.1556 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.832 ns/day, 13.099 hours/ns, 21.206 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    | 47.002     | 47.002     | 47.002     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021852   | 0.021852   | 0.021852   |   0.0 |  0.05
Output  | 3.8683e-05 | 3.8683e-05 | 3.8683e-05 |   0.0 |  0.00
Modify  | 0.12111    | 0.12111    | 0.12111    |   0.0 |  0.26
Other   |            | 0.01067    |            |       |  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:       318812 ave      318812 max      318812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318812
Ave neighs/atom = 79.703
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.582350843064, Press = 0.821482122674221
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11117.331     -11117.331     -11261.347     -11261.347      278.61         278.61         68626.951      68626.951      1250.0276      1250.0276    
     16000  -11118.648     -11118.648     -11255.518     -11255.518      264.78407      264.78407      68738.213      68738.213      66.61749       66.61749     
Loop time of 47.1322 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.833 ns/day, 13.092 hours/ns, 21.217 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.978     | 46.978     | 46.978     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021893   | 0.021893   | 0.021893   |   0.0 |  0.05
Output  | 3.739e-05  | 3.739e-05  | 3.739e-05  |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.26
Other   |            | 0.01062    |            |       |  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:       318826 ave      318826 max      318826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318826
Ave neighs/atom = 79.7065
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.644534239559, Press = 0.410175367453319
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11118.648     -11118.648     -11255.518     -11255.518      264.78407      264.78407      68738.213      68738.213      66.61749       66.61749     
     17000  -11121.508     -11121.508     -11261.898     -11261.898      271.59375      271.59375      68673.517      68673.517      526.32795      526.32795    
Loop time of 47.1917 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.831 ns/day, 13.109 hours/ns, 21.190 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    | 47.038     | 47.038     | 47.038     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021956   | 0.021956   | 0.021956   |   0.0 |  0.05
Output  | 2.9034e-05 | 2.9034e-05 | 2.9034e-05 |   0.0 |  0.00
Modify  | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.26
Other   |            | 0.01063    |            |       |  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:       318696 ave      318696 max      318696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318696
Ave neighs/atom = 79.674
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.598504205759, Press = 1.92825295588901
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11121.508     -11121.508     -11261.898     -11261.898      271.59375      271.59375      68673.517      68673.517      526.32795      526.32795    
     18000  -11117.821     -11117.821     -11259.695     -11259.695      274.46445      274.46445      68709.92       68709.92       162.04427      162.04427    
Loop time of 47.0761 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.835 ns/day, 13.077 hours/ns, 21.242 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.923     | 46.923     | 46.923     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021783   | 0.021783   | 0.021783   |   0.0 |  0.05
Output  | 4.7629e-05 | 4.7629e-05 | 4.7629e-05 |   0.0 |  0.00
Modify  | 0.121      | 0.121      | 0.121      |   0.0 |  0.26
Other   |            | 0.01058    |            |       |  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:       318638 ave      318638 max      318638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318638
Ave neighs/atom = 79.6595
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.44553986911, Press = 1.51760595598246
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11117.821     -11117.821     -11259.695     -11259.695      274.46445      274.46445      68709.92       68709.92       162.04427      162.04427    
     19000  -11118.155     -11118.155     -11260.884     -11260.884      276.11956      276.11956      68683.874      68683.874      469.43239      469.43239    
Loop time of 47.1746 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.831 ns/day, 13.104 hours/ns, 21.198 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    | 47.021     | 47.021     | 47.021     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02196    | 0.02196    | 0.02196    |   0.0 |  0.05
Output  | 4.2801e-05 | 4.2801e-05 | 4.2801e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.26
Other   |            | 0.01067    |            |       |  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:       318756 ave      318756 max      318756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318756
Ave neighs/atom = 79.689
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.432389942563, Press = -0.493873939887062
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11118.155     -11118.155     -11260.884     -11260.884      276.11956      276.11956      68683.874      68683.874      469.43239      469.43239    
     20000  -11117.415     -11117.415     -11257.49      -11257.49       270.98611      270.98611      68752.698      68752.698     -314.89542     -314.89542    
Loop time of 47.1936 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.831 ns/day, 13.109 hours/ns, 21.189 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    | 47.04      | 47.04      | 47.04      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021933   | 0.021933   | 0.021933   |   0.0 |  0.05
Output  | 4.0717e-05 | 4.0717e-05 | 4.0717e-05 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.26
Other   |            | 0.0107     |            |       |  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:       318616 ave      318616 max      318616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318616
Ave neighs/atom = 79.654
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.399741723135, Press = -2.921369441588
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11117.415     -11117.415     -11257.49      -11257.49       270.98611      270.98611      68752.698      68752.698     -314.89542     -314.89542    
     21000  -11116.111     -11116.111     -11257.301     -11257.301      273.14163      273.14163      68773.094      68773.094     -617.52514     -617.52514    
Loop time of 47.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.828 ns/day, 13.126 hours/ns, 21.162 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    | 47.1       | 47.1       | 47.1       |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022096   | 0.022096   | 0.022096   |   0.0 |  0.05
Output  | 2.9856e-05 | 2.9856e-05 | 2.9856e-05 |   0.0 |  0.00
Modify  | 0.12111    | 0.12111    | 0.12111    |   0.0 |  0.26
Other   |            | 0.01062    |            |       |  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:       318656 ave      318656 max      318656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318656
Ave neighs/atom = 79.664
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.408927451423, Press = -1.03464147294076
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11116.111     -11116.111     -11257.301     -11257.301      273.14163      273.14163      68773.094      68773.094     -617.52514     -617.52514    
     22000  -11119.887     -11119.887     -11262.962     -11262.962      276.78806      276.78806      68694.448      68694.448      53.588511      53.588511    
Loop time of 47.2015 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.112 hours/ns, 21.186 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    | 47.048     | 47.048     | 47.048     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021996   | 0.021996   | 0.021996   |   0.0 |  0.05
Output  | 4.1558e-05 | 4.1558e-05 | 4.1558e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.26
Other   |            | 0.01068    |            |       |  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:       318634 ave      318634 max      318634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318634
Ave neighs/atom = 79.6585
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.305807758733, Press = 1.00048762075509
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11119.887     -11119.887     -11262.962     -11262.962      276.78806      276.78806      68694.448      68694.448      53.588511      53.588511    
     23000  -11118.077     -11118.077     -11260.618     -11260.618      275.75619      275.75619      68714.059      68714.059     -8.4779842     -8.4779842    
Loop time of 47.3237 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.826 ns/day, 13.145 hours/ns, 21.131 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    | 47.17      | 47.17      | 47.17      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021994   | 0.021994   | 0.021994   |   0.0 |  0.05
Output  | 3.9655e-05 | 3.9655e-05 | 3.9655e-05 |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  0.26
Other   |            | 0.01068    |            |       |  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:       318702 ave      318702 max      318702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318702
Ave neighs/atom = 79.6755
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.350849014581, Press = 0.634670951008249
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11118.077     -11118.077     -11260.618     -11260.618      275.75619      275.75619      68714.059      68714.059     -8.4779842     -8.4779842    
     24000  -11114.868     -11114.868     -11257.639     -11257.639      276.19893      276.19893      68768.458      68768.458     -556.92084     -556.92084    
Loop time of 47.2706 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.828 ns/day, 13.131 hours/ns, 21.155 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    | 47.117     | 47.117     | 47.117     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021895   | 0.021895   | 0.021895   |   0.0 |  0.05
Output  | 6.2207e-05 | 6.2207e-05 | 6.2207e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.26
Other   |            | 0.01063    |            |       |  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:       318666 ave      318666 max      318666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318666
Ave neighs/atom = 79.6665
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.375168833667, Press = 1.62673026139586
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11114.868     -11114.868     -11257.639     -11257.639      276.19893      276.19893      68768.458      68768.458     -556.92084     -556.92084    
     25000  -11118.39      -11118.39      -11260.797     -11260.797      275.49573      275.49573      68767.469      68767.469     -875.78406     -875.78406    
Loop time of 47.3666 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.824 ns/day, 13.157 hours/ns, 21.112 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    | 47.213     | 47.213     | 47.213     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021942   | 0.021942   | 0.021942   |   0.0 |  0.05
Output  | 4.0176e-05 | 4.0176e-05 | 4.0176e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.26
Other   |            | 0.01069    |            |       |  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:       318626 ave      318626 max      318626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318626
Ave neighs/atom = 79.6565
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.472473679811, Press = 2.52037693876381
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11118.39      -11118.39      -11260.797     -11260.797      275.49573      275.49573      68767.469      68767.469     -875.78406     -875.78406    
     26000  -11118.133     -11118.133     -11257.749     -11257.749      270.09553      270.09553      68628.881      68628.881      1530.2055      1530.2055    
Loop time of 47.2901 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.827 ns/day, 13.136 hours/ns, 21.146 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    | 47.136     | 47.136     | 47.136     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021897   | 0.021897   | 0.021897   |   0.0 |  0.05
Output  | 2.9385e-05 | 2.9385e-05 | 2.9385e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.26
Other   |            | 0.01065    |            |       |  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:       318600 ave      318600 max      318600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318600
Ave neighs/atom = 79.65
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.46851130992, Press = 1.70207633168772
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11118.133     -11118.133     -11257.749     -11257.749      270.09553      270.09553      68628.881      68628.881      1530.2055      1530.2055    
     27000  -11111.814     -11111.814     -11257.499     -11257.499      281.83801      281.83801      68672.032      68672.032      919.94614      919.94614    
Loop time of 47.3363 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.825 ns/day, 13.149 hours/ns, 21.125 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    | 47.183     | 47.183     | 47.183     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021887   | 0.021887   | 0.021887   |   0.0 |  0.05
Output  | 3.9395e-05 | 3.9395e-05 | 3.9395e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.26
Other   |            | 0.01062    |            |       |  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:       319026 ave      319026 max      319026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 319026
Ave neighs/atom = 79.7565
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.533465626929, Press = 0.30080639302468
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11111.814     -11111.814     -11257.499     -11257.499      281.83801      281.83801      68672.032      68672.032      919.94614      919.94614    
     28000  -11119.744     -11119.744     -11259.265     -11259.265      269.91153      269.91153      68716.22       68716.22       41.116498      41.116498    
Loop time of 47.2873 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.827 ns/day, 13.135 hours/ns, 21.147 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    | 47.133     | 47.133     | 47.133     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021858   | 0.021858   | 0.021858   |   0.0 |  0.05
Output  | 5.3991e-05 | 5.3991e-05 | 5.3991e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.26
Other   |            | 0.01064    |            |       |  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:       318808 ave      318808 max      318808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318808
Ave neighs/atom = 79.702
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.5690984265, Press = -0.157521238722483
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11119.744     -11119.744     -11259.265     -11259.265      269.91153      269.91153      68716.22       68716.22       41.116498      41.116498    
     29000  -11115.97      -11115.97      -11257.115     -11257.115      273.05429      273.05429      68787.011      68787.011     -779.39017     -779.39017    
Loop time of 47.182 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.831 ns/day, 13.106 hours/ns, 21.195 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    | 47.029     | 47.029     | 47.029     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021693   | 0.021693   | 0.021693   |   0.0 |  0.05
Output  | 0.00010854 | 0.00010854 | 0.00010854 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.26
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:       318662 ave      318662 max      318662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318662
Ave neighs/atom = 79.6655
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.605548205199, Press = -0.507240307766306
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -11115.97      -11115.97      -11257.115     -11257.115      273.05429      273.05429      68787.011      68787.011     -779.39017     -779.39017    
     30000  -11116.813     -11116.813     -11258.559     -11258.559      274.21824      274.21824      68748.552      68748.552     -288.2385      -288.2385     
Loop time of 47.2245 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.118 hours/ns, 21.175 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    | 47.071     | 47.071     | 47.071     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021777   | 0.021777   | 0.021777   |   0.0 |  0.05
Output  | 7.0964e-05 | 7.0964e-05 | 7.0964e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.26
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:       318594 ave      318594 max      318594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318594
Ave neighs/atom = 79.6485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.584168859775, Press = 0.0381321981585258
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     30000  -11116.813     -11116.813     -11258.559     -11258.559      274.21824      274.21824      68748.552      68748.552     -288.2385      -288.2385     
     31000  -11119.958     -11119.958     -11261.401     -11261.401      273.62966      273.62966      68729.821      68729.821     -335.69279     -335.69279    
Loop time of 47.1761 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.831 ns/day, 13.104 hours/ns, 21.197 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    | 47.023     | 47.023     | 47.023     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021712   | 0.021712   | 0.021712   |   0.0 |  0.05
Output  | 3.4786e-05 | 3.4786e-05 | 3.4786e-05 |   0.0 |  0.00
Modify  | 0.12103    | 0.12103    | 0.12103    |   0.0 |  0.26
Other   |            | 0.01034    |            |       |  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:       318532 ave      318532 max      318532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318532
Ave neighs/atom = 79.633
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.5503870357, Press = 0.445159627479898
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     31000  -11119.958     -11119.958     -11261.401     -11261.401      273.62966      273.62966      68729.821      68729.821     -335.69279     -335.69279    
     32000  -11116.263     -11116.263     -11257.249     -11257.249      272.74669      272.74669      68751.173      68751.173     -239.21581     -239.21581    
Loop time of 47.2917 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.827 ns/day, 13.137 hours/ns, 21.145 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    | 47.138     | 47.138     | 47.138     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021824   | 0.021824   | 0.021824   |   0.0 |  0.05
Output  | 6.4662e-05 | 6.4662e-05 | 6.4662e-05 |   0.0 |  0.00
Modify  | 0.12097    | 0.12097    | 0.12097    |   0.0 |  0.26
Other   |            | 0.01035    |            |       |  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:       318710 ave      318710 max      318710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318710
Ave neighs/atom = 79.6775
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.581214903271, Press = 0.397693079224039
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     32000  -11116.263     -11116.263     -11257.249     -11257.249      272.74669      272.74669      68751.173      68751.173     -239.21581     -239.21581    
     33000  -11122.542     -11122.542     -11263.094     -11263.094      271.90738      271.90738      68699.046      68699.046     -80.361745     -80.361745    
Loop time of 47.3032 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.827 ns/day, 13.140 hours/ns, 21.140 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    | 47.15      | 47.15      | 47.15      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021671   | 0.021671   | 0.021671   |   0.0 |  0.05
Output  | 6.6525e-05 | 6.6525e-05 | 6.6525e-05 |   0.0 |  0.00
Modify  | 0.121      | 0.121      | 0.121      |   0.0 |  0.26
Other   |            | 0.01033    |            |       |  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:       318658 ave      318658 max      318658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318658
Ave neighs/atom = 79.6645
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.583277253931, Press = -0.238083033721243
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     33000  -11122.542     -11122.542     -11263.094     -11263.094      271.90738      271.90738      68699.046      68699.046     -80.361745     -80.361745    
     34000  -11116.319     -11116.319     -11257.653     -11257.653      273.42022      273.42022      68818.6        68818.6       -1385.2347     -1385.2347    
Loop time of 47.2368 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.829 ns/day, 13.121 hours/ns, 21.170 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    | 47.084     | 47.084     | 47.084     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021794   | 0.021794   | 0.021794   |   0.0 |  0.05
Output  | 6.6545e-05 | 6.6545e-05 | 6.6545e-05 |   0.0 |  0.00
Modify  | 0.121      | 0.121      | 0.121      |   0.0 |  0.26
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:       318676 ave      318676 max      318676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318676
Ave neighs/atom = 79.669
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.55533770303, Press = -0.225547248113456
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     34000  -11116.319     -11116.319     -11257.653     -11257.653      273.42022      273.42022      68818.6        68818.6       -1385.2347     -1385.2347    
     35000  -11118.398     -11118.398     -11258.957     -11258.957      271.92118      271.92118      68854.951      68854.951     -1982.0615     -1982.0615    
Loop time of 47.2101 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.114 hours/ns, 21.182 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    | 47.057     | 47.057     | 47.057     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021785   | 0.021785   | 0.021785   |   0.0 |  0.05
Output  | 3.4344e-05 | 3.4344e-05 | 3.4344e-05 |   0.0 |  0.00
Modify  | 0.12096    | 0.12096    | 0.12096    |   0.0 |  0.26
Other   |            | 0.01032    |            |       |  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:       318410 ave      318410 max      318410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318410
Ave neighs/atom = 79.6025
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.573713690635, Press = 0.525983327034948
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     35000  -11118.398     -11118.398     -11258.957     -11258.957      271.92118      271.92118      68854.951      68854.951     -1982.0615     -1982.0615    
     36000  -11119.45      -11119.45      -11257.875     -11257.875      267.79386      267.79386      68764.199      68764.199     -610.73735     -610.73735    
Loop time of 47.3129 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.826 ns/day, 13.142 hours/ns, 21.136 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    | 47.16      | 47.16      | 47.16      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02187    | 0.02187    | 0.02187    |   0.0 |  0.05
Output  | 4.9393e-05 | 4.9393e-05 | 4.9393e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.26
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:       318326 ave      318326 max      318326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318326
Ave neighs/atom = 79.5815
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.578106760766, Press = 1.02221308886459
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     36000  -11119.45      -11119.45      -11257.875     -11257.875      267.79386      267.79386      68764.199      68764.199     -610.73735     -610.73735    
     37000  -11121.327     -11121.327     -11260.689     -11260.689      269.60426      269.60426      68700.39       68700.39       82.759855      82.759855    
Loop time of 47.2567 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.828 ns/day, 13.127 hours/ns, 21.161 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    | 47.103     | 47.103     | 47.103     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021804   | 0.021804   | 0.021804   |   0.0 |  0.05
Output  | 6.89e-05   | 6.89e-05   | 6.89e-05   |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.26
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:       318592 ave      318592 max      318592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318592
Ave neighs/atom = 79.648
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.530359270473, Press = 0.25969746634258
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     37000  -11121.327     -11121.327     -11260.689     -11260.689      269.60426      269.60426      68700.39       68700.39       82.759855      82.759855    
     38000  -11118.469     -11118.469     -11258.586     -11258.586      271.06673      271.06673      68746.216      68746.216     -385.92923     -385.92923    
Loop time of 47.2411 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.829 ns/day, 13.123 hours/ns, 21.168 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    | 47.088     | 47.088     | 47.088     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021796   | 0.021796   | 0.021796   |   0.0 |  0.05
Output  | 6.1405e-05 | 6.1405e-05 | 6.1405e-05 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.26
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:       318696 ave      318696 max      318696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318696
Ave neighs/atom = 79.674
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.477912610438, Press = 0.244561007445917
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     38000  -11118.469     -11118.469     -11258.586     -11258.586      271.06673      271.06673      68746.216      68746.216     -385.92923     -385.92923    
     39000  -11114.516     -11114.516     -11258.062     -11258.062      277.69991      277.69991      68776.472      68776.472     -663.70982     -663.70982    
Loop time of 47.3802 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.824 ns/day, 13.161 hours/ns, 21.106 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    | 47.227     | 47.227     | 47.227     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021805   | 0.021805   | 0.021805   |   0.0 |  0.05
Output  | 6.6715e-05 | 6.6715e-05 | 6.6715e-05 |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.26
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:       318602 ave      318602 max      318602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318602
Ave neighs/atom = 79.6505
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.516839354258, Press = 1.32240472346383
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     39000  -11114.516     -11114.516     -11258.062     -11258.062      277.69991      277.69991      68776.472      68776.472     -663.70982     -663.70982    
     40000  -11120.203     -11120.203     -11259.753     -11259.753      269.96896      269.96896      68727.358      68727.358     -215.40871     -215.40871    
Loop time of 47.2461 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.829 ns/day, 13.124 hours/ns, 21.166 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    | 47.093     | 47.093     | 47.093     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021794   | 0.021794   | 0.021794   |   0.0 |  0.05
Output  | 4.4254e-05 | 4.4254e-05 | 4.4254e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.26
Other   |            | 0.01035    |            |       |  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:       318540 ave      318540 max      318540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318540
Ave neighs/atom = 79.635
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.524643873305, Press = 1.38987866285999
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     40000  -11120.203     -11120.203     -11259.753     -11259.753      269.96896      269.96896      68727.358      68727.358     -215.40871     -215.40871    
     41000  -11121.173     -11121.173     -11259.091     -11259.091      266.81133      266.81133      68716.323      68716.323     -3.7144917     -3.7144917    
Loop time of 47.2772 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.828 ns/day, 13.133 hours/ns, 21.152 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    | 47.124     | 47.124     | 47.124     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021743   | 0.021743   | 0.021743   |   0.0 |  0.05
Output  | 5.6706e-05 | 5.6706e-05 | 5.6706e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.26
Other   |            | 0.01035    |            |       |  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:       318834 ave      318834 max      318834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318834
Ave neighs/atom = 79.7085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.499179349456, Press = 0.668777730054983
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     41000  -11121.173     -11121.173     -11259.091     -11259.091      266.81133      266.81133      68716.323      68716.323     -3.7144917     -3.7144917    
     42000  -11119.395     -11119.395     -11260.812     -11260.812      273.58214      273.58214      68710.889      68710.889     -118.88422     -118.88422    
Loop time of 47.2013 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.830 ns/day, 13.111 hours/ns, 21.186 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    | 47.048     | 47.048     | 47.048     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021876   | 0.021876   | 0.021876   |   0.0 |  0.05
Output  | 4.8662e-05 | 4.8662e-05 | 4.8662e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.26
Other   |            | 0.01035    |            |       |  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:       318800 ave      318800 max      318800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318800
Ave neighs/atom = 79.7
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.44739568837, Press = 0.859624587302083
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     42000  -11119.395     -11119.395     -11260.812     -11260.812      273.58214      273.58214      68710.889      68710.889     -118.88422     -118.88422    
     43000  -11117.663     -11117.663     -11258.888     -11258.888      273.20929      273.20929      68714.471      68714.471      61.918344      61.918344    
Loop time of 47.3111 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.826 ns/day, 13.142 hours/ns, 21.137 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    | 47.158     | 47.158     | 47.158     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021772   | 0.021772   | 0.021772   |   0.0 |  0.05
Output  | 5.4442e-05 | 5.4442e-05 | 5.4442e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.26
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:       318696 ave      318696 max      318696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318696
Ave neighs/atom = 79.674
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.426393777005, Press = 0.698681619838792
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     43000  -11117.663     -11117.663     -11258.888     -11258.888      273.20929      273.20929      68714.471      68714.471      61.918344      61.918344    
     44000  -11120.552     -11120.552     -11259.4       -11259.4        268.6109       268.6109       68710.088      68710.088      179.19526      179.19526    
Loop time of 47.2945 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.827 ns/day, 13.137 hours/ns, 21.144 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    | 47.141     | 47.141     | 47.141     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02183    | 0.02183    | 0.02183    |   0.0 |  0.05
Output  | 5.835e-05  | 5.835e-05  | 5.835e-05  |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.26
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:       318854 ave      318854 max      318854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318854
Ave neighs/atom = 79.7135
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.416588846446, Press = 1.39730694713666
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     44000  -11120.552     -11120.552     -11259.4       -11259.4        268.6109       268.6109       68710.088      68710.088      179.19526      179.19526    
     45000  -11118.368     -11118.368     -11258.332     -11258.332      270.77028      270.77028      68733.426      68733.426     -158.9582      -158.9582     
Loop time of 47.3266 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.826 ns/day, 13.146 hours/ns, 21.130 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    | 47.173     | 47.173     | 47.173     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021817   | 0.021817   | 0.021817   |   0.0 |  0.05
Output  | 3.4095e-05 | 3.4095e-05 | 3.4095e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.26
Other   |            | 0.01038    |            |       |  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:       318722 ave      318722 max      318722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318722
Ave neighs/atom = 79.6805
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.393781215885, Press = 1.30300972502468
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     45000  -11118.368     -11118.368     -11258.332     -11258.332      270.77028      270.77028      68733.426      68733.426     -158.9582      -158.9582     
     46000  -11120.273     -11120.273     -11261.883     -11261.883      273.95424      273.95424      68658.578      68658.578      701.35543      701.35543    
Loop time of 47.3349 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.825 ns/day, 13.149 hours/ns, 21.126 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    | 47.181     | 47.181     | 47.181     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021691   | 0.021691   | 0.021691   |   0.0 |  0.05
Output  | 6.7447e-05 | 6.7447e-05 | 6.7447e-05 |   0.0 |  0.00
Modify  | 0.12133    | 0.12133    | 0.12133    |   0.0 |  0.26
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:       318738 ave      318738 max      318738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318738
Ave neighs/atom = 79.6845
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.364407695106, Press = 0.456924625118529
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     46000  -11120.273     -11120.273     -11261.883     -11261.883      273.95424      273.95424      68658.578      68658.578      701.35543      701.35543    
     47000  -11114.033     -11114.033     -11257.211     -11257.211      276.98708      276.98708      68664.206      68664.206      1011.8171      1011.8171    
Loop time of 47.2704 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.828 ns/day, 13.131 hours/ns, 21.155 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    | 47.117     | 47.117     | 47.117     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021765   | 0.021765   | 0.021765   |   0.0 |  0.05
Output  | 4.8832e-05 | 4.8832e-05 | 4.8832e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.26
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:       318868 ave      318868 max      318868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318868
Ave neighs/atom = 79.717
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.36674765845, Press = 0.516084933266359
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     47000  -11114.033     -11114.033     -11257.211     -11257.211      276.98708      276.98708      68664.206      68664.206      1011.8171      1011.8171    
     48000  -11117.908     -11117.908     -11258.19      -11258.19       271.38616      271.38616      68701.484      68701.484      362.62249      362.62249    
Loop time of 47.3505 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.825 ns/day, 13.153 hours/ns, 21.119 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    | 47.197     | 47.197     | 47.197     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021962   | 0.021962   | 0.021962   |   0.0 |  0.05
Output  | 5.3601e-05 | 5.3601e-05 | 5.3601e-05 |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.26
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:       318898 ave      318898 max      318898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318898
Ave neighs/atom = 79.7245
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.357248933849, Press = 0.631608053201742
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     48000  -11117.908     -11117.908     -11258.19      -11258.19       271.38616      271.38616      68701.484      68701.484      362.62249      362.62249    
     49000  -11118.195     -11118.195     -11259.153     -11259.153      272.6915       272.6915       68751.259      68751.259     -549.20819     -549.20819    
Loop time of 47.3405 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.825 ns/day, 13.150 hours/ns, 21.124 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    | 47.187     | 47.187     | 47.187     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021824   | 0.021824   | 0.021824   |   0.0 |  0.05
Output  | 3.8011e-05 | 3.8011e-05 | 3.8011e-05 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.26
Other   |            | 0.01034    |            |       |  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:       318738 ave      318738 max      318738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318738
Ave neighs/atom = 79.6845
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.320932952501, Press = 0.315586537968045
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     49000  -11118.195     -11118.195     -11259.153     -11259.153      272.6915       272.6915       68751.259      68751.259     -549.20819     -549.20819    
     50000  -11118.616     -11118.616     -11260.821     -11260.821      275.10645      275.10645      68760.642      68760.642     -815.2239      -815.2239     
Loop time of 47.2614 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.828 ns/day, 13.128 hours/ns, 21.159 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    | 47.108     | 47.108     | 47.108     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021772   | 0.021772   | 0.021772   |   0.0 |  0.05
Output  | 5.9182e-05 | 5.9182e-05 | 5.9182e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.26
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:       318638 ave      318638 max      318638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318638
Ave neighs/atom = 79.6595
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.32553718775, Press = 1.66427237340795
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     50000  -11118.616     -11118.616     -11260.821     -11260.821      275.10645      275.10645      68760.642      68760.642     -815.2239      -815.2239     
     51000  -11116.669     -11116.669     -11259.502     -11259.502      276.32164      276.32164      68731.425      68731.425     -257.04663     -257.04663    
Loop time of 47.3222 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.826 ns/day, 13.145 hours/ns, 21.132 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    | 47.169     | 47.169     | 47.169     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021797   | 0.021797   | 0.021797   |   0.0 |  0.05
Output  | 5.347e-05  | 5.347e-05  | 5.347e-05  |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.26
Other   |            | 0.01038    |            |       |  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:       318652 ave      318652 max      318652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318652
Ave neighs/atom = 79.663
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.327853446056, Press = 0.357340024149587
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   
     51000  -11116.669     -11116.669     -11259.502     -11259.502      276.32164      276.32164      68731.425      68731.425     -257.04663     -257.04663    
     52000  -11116.671     -11116.671     -11259.955     -11259.955      277.19271      277.19271      68783.266      68783.266     -968.78924     -968.78924    
Loop time of 47.3778 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.824 ns/day, 13.161 hours/ns, 21.107 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    | 47.224     | 47.224     | 47.224     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021756   | 0.021756   | 0.021756   |   0.0 |  0.05
Output  | 0.00013394 | 0.00013394 | 0.00013394 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.26
Other   |            | 0.01038    |            |       |  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:       318788 ave      318788 max      318788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 318788
Ave neighs/atom = 79.697
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
68718.4719023884

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0