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

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

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

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

kim_interactions Mo

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

kim interactions Mo
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ParkFellingerLenosky_2012_Mo__MO_269937397263_002
pair_coeff * * Mo
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 95.94

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31777.0908166668 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_269937397263_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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13553.84      -13553.84      -13634.755     -13634.755      313.15         313.15         31777.091      31777.091      2719.7564      2719.7564    
      1000  -13472.054     -13472.054     -13551.766     -13551.766      308.49277      308.49277      31947.933      31947.933     -235.99288     -235.99288    
Loop time of 576.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 160.241 hours/ns, 1.734 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 576.34     | 576.34     | 576.34     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10372    | 0.10372    | 0.10372    |   0.0 |  0.02
Output  | 0.00025181 | 0.00025181 | 0.00025181 |   0.0 |  0.00
Modify  | 0.36468    | 0.36468    | 0.36468    |   0.0 |  0.06
Other   |            | 0.05708    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       272000 ave      272000 max      272000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272000
Ave neighs/atom = 136
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13472.054     -13472.054     -13551.766     -13551.766      308.49277      308.49277      31947.933      31947.933     -235.99288     -235.99288    
      2000  -13470.245     -13470.245     -13548.116     -13548.116      301.36777      301.36777      31967.533      31967.533     -1853.5944     -1853.5944    
Loop time of 595.821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.506 hours/ns, 1.678 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.26     | 595.26     | 595.26     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11481    | 0.11481    | 0.11481    |   0.0 |  0.02
Output  | 0.00020454 | 0.00020454 | 0.00020454 |   0.0 |  0.00
Modify  | 0.38534    | 0.38534    | 0.38534    |   0.0 |  0.06
Other   |            | 0.05976    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4436 ave        4436 max        4436 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:       269868 ave      269868 max      269868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269868
Ave neighs/atom = 134.934
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13470.245     -13470.245     -13548.116     -13548.116      301.36777      301.36777      31967.533      31967.533     -1853.5944     -1853.5944    
      3000  -13473.793     -13473.793     -13557.033     -13557.033      322.15014      322.15014      31959.19       31959.19      -1977.322      -1977.322     
Loop time of 599.584 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.551 hours/ns, 1.668 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.02     | 599.02     | 599.02     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11549    | 0.11549    | 0.11549    |   0.0 |  0.02
Output  | 0.00020641 | 0.00020641 | 0.00020641 |   0.0 |  0.00
Modify  | 0.38966    | 0.38966    | 0.38966    |   0.0 |  0.06
Other   |            | 0.05953    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4444 ave        4444 max        4444 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:       269276 ave      269276 max      269276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269276
Ave neighs/atom = 134.638
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13473.793     -13473.793     -13557.033     -13557.033      322.15014      322.15014      31959.19       31959.19      -1977.322      -1977.322     
      4000  -13469.06      -13469.06      -13555.297     -13555.297      333.74841      333.74841      31917.94       31917.94       1675.0254      1675.0254    
Loop time of 600.828 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.897 hours/ns, 1.664 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.26     | 600.26     | 600.26     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1172     | 0.1172     | 0.1172     |   0.0 |  0.02
Output  | 0.00024647 | 0.00024647 | 0.00024647 |   0.0 |  0.00
Modify  | 0.39461    | 0.39461    | 0.39461    |   0.0 |  0.07
Other   |            | 0.06058    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4449 ave        4449 max        4449 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:       270006 ave      270006 max      270006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270006
Ave neighs/atom = 135.003
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13469.06      -13469.06      -13555.297     -13555.297      333.74841      333.74841      31917.94       31917.94       1675.0254      1675.0254    
      5000  -13473.09      -13473.09      -13550.228     -13550.228      298.53348      298.53348      31904.549      31904.549      3476.7442      3476.7442    
Loop time of 598.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.214 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.8      | 597.8      | 597.8      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11473    | 0.11473    | 0.11473    |   0.0 |  0.02
Output  | 0.00020576 | 0.00020576 | 0.00020576 |   0.0 |  0.00
Modify  | 0.39163    | 0.39163    | 0.39163    |   0.0 |  0.07
Other   |            | 0.06038    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4439 ave        4439 max        4439 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:       270170 ave      270170 max      270170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270170
Ave neighs/atom = 135.085
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 = 306.177739665562, Press = -30.0481111251411
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13473.09      -13473.09      -13550.228     -13550.228      298.53348      298.53348      31904.549      31904.549      3476.7442      3476.7442    
      6000  -13471.019     -13471.019     -13553.506     -13553.506      319.23306      319.23306      31947.548      31947.548     -477.17356     -477.17356    
Loop time of 596.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.768 hours/ns, 1.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.18     | 596.18     | 596.18     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11685    | 0.11685    | 0.11685    |   0.0 |  0.02
Output  | 0.00016576 | 0.00016576 | 0.00016576 |   0.0 |  0.00
Modify  | 0.40878    | 0.40878    | 0.40878    |   0.0 |  0.07
Other   |            | 0.06002    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4480 ave        4480 max        4480 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:       270022 ave      270022 max      270022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270022
Ave neighs/atom = 135.011
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 = 311.827308268899, Press = -26.4631216415205
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13471.019     -13471.019     -13553.506     -13553.506      319.23306      319.23306      31947.548      31947.548     -477.17356     -477.17356    
      7000  -13473.633     -13473.633     -13559.868     -13559.868      333.73688      333.73688      31949.734      31949.734     -1286.5501     -1286.5501    
Loop time of 591.892 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.414 hours/ns, 1.689 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 591.31     | 591.31     | 591.31     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11564    | 0.11564    | 0.11564    |   0.0 |  0.02
Output  | 0.00024892 | 0.00024892 | 0.00024892 |   0.0 |  0.00
Modify  | 0.40635    | 0.40635    | 0.40635    |   0.0 |  0.07
Other   |            | 0.05883    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4450 ave        4450 max        4450 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:       269890 ave      269890 max      269890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269890
Ave neighs/atom = 134.945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.087908929556, Press = -15.2520857221576
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13473.633     -13473.633     -13559.868     -13559.868      333.73688      333.73688      31949.734      31949.734     -1286.5501     -1286.5501    
      8000  -13470.787     -13470.787     -13549.189     -13549.189      303.42275      303.42275      31896.483      31896.483      3578.9619      3578.9619    
Loop time of 591.196 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.221 hours/ns, 1.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 590.62     | 590.62     | 590.62     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11518    | 0.11518    | 0.11518    |   0.0 |  0.02
Output  | 0.00026186 | 0.00026186 | 0.00026186 |   0.0 |  0.00
Modify  | 0.40197    | 0.40197    | 0.40197    |   0.0 |  0.07
Other   |            | 0.05976    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4474 ave        4474 max        4474 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:       270314 ave      270314 max      270314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270314
Ave neighs/atom = 135.157
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 = 312.13802982658, Press = -22.6209699695901
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13470.787     -13470.787     -13549.189     -13549.189      303.42275      303.42275      31896.483      31896.483      3578.9619      3578.9619    
      9000  -13472.074     -13472.074     -13554.205     -13554.205      317.85421      317.85421      31912.006      31912.006      2206.9848      2206.9848    
Loop time of 594.718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.199 hours/ns, 1.681 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.13     | 594.13     | 594.13     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11613    | 0.11613    | 0.11613    |   0.0 |  0.02
Output  | 0.00016841 | 0.00016841 | 0.00016841 |   0.0 |  0.00
Modify  | 0.4075     | 0.4075     | 0.4075     |   0.0 |  0.07
Other   |            | 0.05957    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4494 ave        4494 max        4494 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:       269816 ave      269816 max      269816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269816
Ave neighs/atom = 134.908
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.874561105734, Press = 6.58974505119086
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13472.074     -13472.074     -13554.205     -13554.205      317.85421      317.85421      31912.006      31912.006      2206.9848      2206.9848    
     10000  -13475.329     -13475.329     -13552.588     -13552.588      298.99969      298.99969      31981.235      31981.235     -3263.0964     -3263.0964    
Loop time of 585.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 162.612 hours/ns, 1.708 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 584.83     | 584.83     | 584.83     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11385    | 0.11385    | 0.11385    |   0.0 |  0.02
Output  | 0.00018559 | 0.00018559 | 0.00018559 |   0.0 |  0.00
Modify  | 0.39467    | 0.39467    | 0.39467    |   0.0 |  0.07
Other   |            | 0.05866    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4511 ave        4511 max        4511 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:       270220 ave      270220 max      270220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270220
Ave neighs/atom = 135.11
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 = 312.166390847345, Press = 4.82494601605852
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13475.329     -13475.329     -13552.588     -13552.588      298.99969      298.99969      31981.235      31981.235     -3263.0964     -3263.0964    
     11000  -13470.842     -13470.842     -13545.985     -13545.985      290.80778      290.80778      31940.979      31940.979      598.08642      598.08642    
Loop time of 603.424 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.618 hours/ns, 1.657 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 602.83     | 602.83     | 602.83     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11638    | 0.11638    | 0.11638    |   0.0 |  0.02
Output  | 0.0001958  | 0.0001958  | 0.0001958  |   0.0 |  0.00
Modify  | 0.41549    | 0.41549    | 0.41549    |   0.0 |  0.07
Other   |            | 0.05981    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4444 ave        4444 max        4444 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:       269706 ave      269706 max      269706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269706
Ave neighs/atom = 134.853
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 = 312.058841516276, Press = -7.44378432049534
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13470.842     -13470.842     -13545.985     -13545.985      290.80778      290.80778      31940.979      31940.979      598.08642      598.08642    
     12000  -13471.853     -13471.853     -13546.344     -13546.344      288.28895      288.28895      31901.117      31901.117      3517.6737      3517.6737    
Loop time of 596.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.680 hours/ns, 1.677 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.86     | 595.86     | 595.86     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11697    | 0.11697    | 0.11697    |   0.0 |  0.02
Output  | 0.00016773 | 0.00016773 | 0.00016773 |   0.0 |  0.00
Modify  | 0.41377    | 0.41377    | 0.41377    |   0.0 |  0.07
Other   |            | 0.05985    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4457 ave        4457 max        4457 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:       269458 ave      269458 max      269458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269458
Ave neighs/atom = 134.729
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 = 312.219820762142, Press = -3.07465063832811
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13471.853     -13471.853     -13546.344     -13546.344      288.28895      288.28895      31901.117      31901.117      3517.6737      3517.6737    
     13000  -13473.415     -13473.415     -13550.381     -13550.381      297.8649       297.8649       31925.118      31925.118      1406.2225      1406.2225    
Loop time of 602.693 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.415 hours/ns, 1.659 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 602.1      | 602.1      | 602.1      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11881    | 0.11881    | 0.11881    |   0.0 |  0.02
Output  | 0.00021016 | 0.00021016 | 0.00021016 |   0.0 |  0.00
Modify  | 0.41205    | 0.41205    | 0.41205    |   0.0 |  0.07
Other   |            | 0.06038    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4552 ave        4552 max        4552 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:       269564 ave      269564 max      269564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269564
Ave neighs/atom = 134.782
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 = 312.255218294194, Press = 2.16161581556746
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13473.415     -13473.415     -13550.381     -13550.381      297.8649       297.8649       31925.118      31925.118      1406.2225      1406.2225    
     14000  -13473.72      -13473.72      -13553.099     -13553.099      307.20763      307.20763      31976.887      31976.887     -2835.5579     -2835.5579    
Loop time of 600.089 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.691 hours/ns, 1.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.5      | 599.5      | 599.5      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11616    | 0.11616    | 0.11616    |   0.0 |  0.02
Output  | 0.00026184 | 0.00026184 | 0.00026184 |   0.0 |  0.00
Modify  | 0.41205    | 0.41205    | 0.41205    |   0.0 |  0.07
Other   |            | 0.05998    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4471 ave        4471 max        4471 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:       269696 ave      269696 max      269696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269696
Ave neighs/atom = 134.848
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 = 312.572810892928, Press = -4.17025230612688
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13473.72      -13473.72      -13553.099     -13553.099      307.20763      307.20763      31976.887      31976.887     -2835.5579     -2835.5579    
     15000  -13470.427     -13470.427     -13550.343     -13550.343      309.28295      309.28295      31942.82       31942.82       119.61308      119.61308    
Loop time of 602.231 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.286 hours/ns, 1.660 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 601.64     | 601.64     | 601.64     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11704    | 0.11704    | 0.11704    |   0.0 |  0.02
Output  | 0.00020732 | 0.00020732 | 0.00020732 |   0.0 |  0.00
Modify  | 0.41817    | 0.41817    | 0.41817    |   0.0 |  0.07
Other   |            | 0.0603     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4449 ave        4449 max        4449 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:       269838 ave      269838 max      269838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269838
Ave neighs/atom = 134.919
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 = 312.52011515382, Press = -4.40826273298132
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13470.427     -13470.427     -13550.343     -13550.343      309.28295      309.28295      31942.82       31942.82       119.61308      119.61308    
     16000  -13473.713     -13473.713     -13555.138     -13555.138      315.12066      315.12066      31930.933      31930.933      310.1527       310.1527     
Loop time of 597.647 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 166.013 hours/ns, 1.673 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.06     | 597.06     | 597.06     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11642    | 0.11642    | 0.11642    |   0.0 |  0.02
Output  | 0.00020724 | 0.00020724 | 0.00020724 |   0.0 |  0.00
Modify  | 0.40927    | 0.40927    | 0.40927    |   0.0 |  0.07
Other   |            | 0.05949    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4435 ave        4435 max        4435 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:       269508 ave      269508 max      269508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269508
Ave neighs/atom = 134.754
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 = 312.381203295564, Press = -4.57505986780883
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13473.713     -13473.713     -13555.138     -13555.138      315.12066      315.12066      31930.933      31930.933      310.1527       310.1527     
     17000  -13473.065     -13473.065     -13554.066     -13554.066      313.48511      313.48511      31930.353      31930.353      525.2934       525.2934     
Loop time of 596.71 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.753 hours/ns, 1.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.12     | 596.12     | 596.12     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11711    | 0.11711    | 0.11711    |   0.0 |  0.02
Output  | 0.00016777 | 0.00016777 | 0.00016777 |   0.0 |  0.00
Modify  | 0.40773    | 0.40773    | 0.40773    |   0.0 |  0.07
Other   |            | 0.0598     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4503 ave        4503 max        4503 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:       269892 ave      269892 max      269892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269892
Ave neighs/atom = 134.946
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 = 312.407667601438, Press = 0.322178697617077
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13473.065     -13473.065     -13554.066     -13554.066      313.48511      313.48511      31930.353      31930.353      525.2934       525.2934     
     18000  -13471.691     -13471.691     -13551.289     -13551.289      308.05233      308.05233      31989.247      31989.247     -3454.2583     -3454.2583    
Loop time of 598.322 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.201 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.73     | 597.73     | 597.73     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11726    | 0.11726    | 0.11726    |   0.0 |  0.02
Output  | 0.00016553 | 0.00016553 | 0.00016553 |   0.0 |  0.00
Modify  | 0.41138    | 0.41138    | 0.41138    |   0.0 |  0.07
Other   |            | 0.06018    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4489 ave        4489 max        4489 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:       269944 ave      269944 max      269944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269944
Ave neighs/atom = 134.972
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 = 312.36296600815, Press = -1.11450894486415
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13471.691     -13471.691     -13551.289     -13551.289      308.05233      308.05233      31989.247      31989.247     -3454.2583     -3454.2583    
     19000  -13475.654     -13475.654     -13551.339     -13551.339      292.9078       292.9078       31972.492      31972.492     -2451.5147     -2451.5147    
Loop time of 600.819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.894 hours/ns, 1.664 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.22     | 600.22     | 600.22     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11784    | 0.11784    | 0.11784    |   0.0 |  0.02
Output  | 0.00016952 | 0.00016952 | 0.00016952 |   0.0 |  0.00
Modify  | 0.41544    | 0.41544    | 0.41544    |   0.0 |  0.07
Other   |            | 0.06088    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4490 ave        4490 max        4490 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:       269422 ave      269422 max      269422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269422
Ave neighs/atom = 134.711
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 = 312.280915529609, Press = -7.99124630175737
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13475.654     -13475.654     -13551.339     -13551.339      292.9078       292.9078       31972.492      31972.492     -2451.5147     -2451.5147    
     20000  -13469.726     -13469.726     -13551.187     -13551.187      315.26083      315.26083      31914.747      31914.747      2302.7848      2302.7848    
Loop time of 594.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.214 hours/ns, 1.681 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.19     | 594.19     | 594.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11536    | 0.11536    | 0.11536    |   0.0 |  0.02
Output  | 0.00020349 | 0.00020349 | 0.00020349 |   0.0 |  0.00
Modify  | 0.40455    | 0.40455    | 0.40455    |   0.0 |  0.07
Other   |            | 0.05964    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4469 ave        4469 max        4469 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:       269498 ave      269498 max      269498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269498
Ave neighs/atom = 134.749
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 = 312.240936816536, Press = -1.14723920420682
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13469.726     -13469.726     -13551.187     -13551.187      315.26083      315.26083      31914.747      31914.747      2302.7848      2302.7848    
     21000  -13476.802     -13476.802     -13552.553     -13552.553      293.16672      293.16672      31933.848      31933.848      426.98066      426.98066    
Loop time of 595.958 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.544 hours/ns, 1.678 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.37     | 595.37     | 595.37     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11709    | 0.11709    | 0.11709    |   0.0 |  0.02
Output  | 0.00021368 | 0.00021368 | 0.00021368 |   0.0 |  0.00
Modify  | 0.41303    | 0.41303    | 0.41303    |   0.0 |  0.07
Other   |            | 0.06021    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4490 ave        4490 max        4490 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:       269974 ave      269974 max      269974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269974
Ave neighs/atom = 134.987
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 = 312.160561349156, Press = 0.332900952254413
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13476.802     -13476.802     -13552.553     -13552.553      293.16672      293.16672      31933.848      31933.848      426.98066      426.98066    
     22000  -13470.481     -13470.481     -13551.083     -13551.083      311.93939      311.93939      31956.467      31956.467     -949.41949     -949.41949    
Loop time of 594.922 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.256 hours/ns, 1.681 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 594.34     | 594.34     | 594.34     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11665    | 0.11665    | 0.11665    |   0.0 |  0.02
Output  | 0.00020885 | 0.00020885 | 0.00020885 |   0.0 |  0.00
Modify  | 0.4093     | 0.4093     | 0.4093     |   0.0 |  0.07
Other   |            | 0.05913    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4513 ave        4513 max        4513 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:       269758 ave      269758 max      269758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269758
Ave neighs/atom = 134.879
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 = 312.170613312785, Press = -2.5294798571361
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13470.481     -13470.481     -13551.083     -13551.083      311.93939      311.93939      31956.467      31956.467     -949.41949     -949.41949    
     23000  -13470.198     -13470.198     -13552.821     -13552.821      319.76023      319.76023      31952.985      31952.985     -774.51349     -774.51349    
Loop time of 596.667 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.741 hours/ns, 1.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.08     | 596.08     | 596.08     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11527    | 0.11527    | 0.11527    |   0.0 |  0.02
Output  | 0.00023411 | 0.00023411 | 0.00023411 |   0.0 |  0.00
Modify  | 0.40811    | 0.40811    | 0.40811    |   0.0 |  0.07
Other   |            | 0.06004    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4428 ave        4428 max        4428 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:       269610 ave      269610 max      269610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269610
Ave neighs/atom = 134.805
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 = 312.260037249799, Press = -4.26177188893821
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13470.198     -13470.198     -13552.821     -13552.821      319.76023      319.76023      31952.985      31952.985     -774.51349     -774.51349    
     24000  -13472.143     -13472.143     -13553.435     -13553.435      314.60839      314.60839      31915.678      31915.678      1754.6096      1754.6096    
Loop time of 598.17 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.158 hours/ns, 1.672 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.58     | 597.58     | 597.58     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11787    | 0.11787    | 0.11787    |   0.0 |  0.02
Output  | 0.00016544 | 0.00016544 | 0.00016544 |   0.0 |  0.00
Modify  | 0.41331    | 0.41331    | 0.41331    |   0.0 |  0.07
Other   |            | 0.06065    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4504 ave        4504 max        4504 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:       269924 ave      269924 max      269924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269924
Ave neighs/atom = 134.962
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 = 312.34199874271, Press = -0.0353047162359516
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13472.143     -13472.143     -13553.435     -13553.435      314.60839      314.60839      31915.678      31915.678      1754.6096      1754.6096    
     25000  -13470.015     -13470.015     -13550.555     -13550.555      311.6954       311.6954       31961.34       31961.34      -1456.9809     -1456.9809    
Loop time of 600.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.725 hours/ns, 1.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.62     | 599.62     | 599.62     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11692    | 0.11692    | 0.11692    |   0.0 |  0.02
Output  | 0.00016244 | 0.00016244 | 0.00016244 |   0.0 |  0.00
Modify  | 0.41435    | 0.41435    | 0.41435    |   0.0 |  0.07
Other   |            | 0.05967    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4480 ave        4480 max        4480 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:       270068 ave      270068 max      270068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270068
Ave neighs/atom = 135.034
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 = 312.449414147062, Press = -0.0083702552348219
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13470.015     -13470.015     -13550.555     -13550.555      311.6954       311.6954       31961.34       31961.34      -1456.9809     -1456.9809    
     26000  -13472.643     -13472.643     -13554.23      -13554.23       315.74721      315.74721      31976.013      31976.013     -2762.5294     -2762.5294    
Loop time of 598.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.225 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.81     | 597.81     | 597.81     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11723    | 0.11723    | 0.11723    |   0.0 |  0.02
Output  | 0.00016556 | 0.00016556 | 0.00016556 |   0.0 |  0.00
Modify  | 0.41776    | 0.41776    | 0.41776    |   0.0 |  0.07
Other   |            | 0.06055    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4445 ave        4445 max        4445 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:       269434 ave      269434 max      269434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269434
Ave neighs/atom = 134.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 = 312.544432445438, Press = -3.73619226157216
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13472.643     -13472.643     -13554.23      -13554.23       315.74721      315.74721      31976.013      31976.013     -2762.5294     -2762.5294    
     27000  -13471.847     -13471.847     -13552.965     -13552.965      313.93457      313.93457      31904.137      31904.137      2946.0883      2946.0883    
Loop time of 595.796 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.499 hours/ns, 1.678 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.22     | 595.22     | 595.22     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11538    | 0.11538    | 0.11538    |   0.0 |  0.02
Output  | 0.00027856 | 0.00027856 | 0.00027856 |   0.0 |  0.00
Modify  | 0.40415    | 0.40415    | 0.40415    |   0.0 |  0.07
Other   |            | 0.05965    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4442 ave        4442 max        4442 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:       269718 ave      269718 max      269718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269718
Ave neighs/atom = 134.859
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.703695229701, Press = -1.51684561057772
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13471.847     -13471.847     -13552.965     -13552.965      313.93457      313.93457      31904.137      31904.137      2946.0883      2946.0883    
     28000  -13471.104     -13471.104     -13551.423     -13551.423      310.84443      310.84443      31939.085      31939.085      57.35339       57.35339     
Loop time of 597.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 166.030 hours/ns, 1.673 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.12     | 597.12     | 597.12     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11733    | 0.11733    | 0.11733    |   0.0 |  0.02
Output  | 0.00016695 | 0.00016695 | 0.00016695 |   0.0 |  0.00
Modify  | 0.41098    | 0.41098    | 0.41098    |   0.0 |  0.07
Other   |            | 0.05961    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4477 ave        4477 max        4477 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:       270170 ave      270170 max      270170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270170
Ave neighs/atom = 135.085
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 = 312.703764478635, Press = 0.527316376723012
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13471.104     -13471.104     -13551.423     -13551.423      310.84443      310.84443      31939.085      31939.085      57.35339       57.35339     
     29000  -13474.417     -13474.417     -13554.683     -13554.683      310.63609      310.63609      31951.293      31951.293     -1084.0057     -1084.0057    
Loop time of 598.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.216 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.79     | 597.79     | 597.79     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11665    | 0.11665    | 0.11665    |   0.0 |  0.02
Output  | 0.00016828 | 0.00016828 | 0.00016828 |   0.0 |  0.00
Modify  | 0.4089     | 0.4089     | 0.4089     |   0.0 |  0.07
Other   |            | 0.05972    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4481 ave        4481 max        4481 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:       269816 ave      269816 max      269816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269816
Ave neighs/atom = 134.908
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.698592447185, Press = -0.690743950977171
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13474.417     -13474.417     -13554.683     -13554.683      310.63609      310.63609      31951.293      31951.293     -1084.0057     -1084.0057    
     30000  -13471.802     -13471.802     -13554.412     -13554.412      319.70768      319.70768      31948.366      31948.366     -669.2785      -669.2785     
Loop time of 596.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.715 hours/ns, 1.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.99     | 595.99     | 595.99     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11478    | 0.11478    | 0.11478    |   0.0 |  0.02
Output  | 0.00017113 | 0.00017113 | 0.00017113 |   0.0 |  0.00
Modify  | 0.41158    | 0.41158    | 0.41158    |   0.0 |  0.07
Other   |            | 0.0599     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4406 ave        4406 max        4406 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:       269910 ave      269910 max      269910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269910
Ave neighs/atom = 134.955
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 = 312.658590724653, Press = -2.39402838219195
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13471.802     -13471.802     -13554.412     -13554.412      319.70768      319.70768      31948.366      31948.366     -669.2785      -669.2785     
     31000  -13467.994     -13467.994     -13552.528     -13552.528      327.15549      327.15549      31902.399      31902.399      3222.2387      3222.2387    
Loop time of 600.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.777 hours/ns, 1.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.81     | 599.81     | 599.81     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11602    | 0.11602    | 0.11602    |   0.0 |  0.02
Output  | 0.00024376 | 0.00024376 | 0.00024376 |   0.0 |  0.00
Modify  | 0.41354    | 0.41354    | 0.41354    |   0.0 |  0.07
Other   |            | 0.05991    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4423 ave        4423 max        4423 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:       269920 ave      269920 max      269920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269920
Ave neighs/atom = 134.96
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 = 312.66930480968, Press = -1.25320071733414
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13467.994     -13467.994     -13552.528     -13552.528      327.15549      327.15549      31902.399      31902.399      3222.2387      3222.2387    
     32000  -13473.252     -13473.252     -13553.176     -13553.176      309.31219      309.31219      31925.202      31925.202      1176.1164      1176.1164    
Loop time of 600.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.707 hours/ns, 1.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 599.56     | 599.56     | 599.56     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11608    | 0.11608    | 0.11608    |   0.0 |  0.02
Output  | 0.00022572 | 0.00022572 | 0.00022572 |   0.0 |  0.00
Modify  | 0.41023    | 0.41023    | 0.41023    |   0.0 |  0.07
Other   |            | 0.05943    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4459 ave        4459 max        4459 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:       270112 ave      270112 max      270112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270112
Ave neighs/atom = 135.056
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 = 312.755609138256, Press = 2.97921209579963
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13473.252     -13473.252     -13553.176     -13553.176      309.31219      309.31219      31925.202      31925.202      1176.1164      1176.1164    
     33000  -13469.67      -13469.67      -13553.824     -13553.824      325.68523      325.68523      31985.613      31985.613     -3260.2289     -3260.2289    
Loop time of 596.089 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.580 hours/ns, 1.678 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 595.5      | 595.5      | 595.5      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11639    | 0.11639    | 0.11639    |   0.0 |  0.02
Output  | 0.0001737  | 0.0001737  | 0.0001737  |   0.0 |  0.00
Modify  | 0.41238    | 0.41238    | 0.41238    |   0.0 |  0.07
Other   |            | 0.06016    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4484 ave        4484 max        4484 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:       269882 ave      269882 max      269882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269882
Ave neighs/atom = 134.941
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 = 312.81748435062, Press = -0.856593096292046
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13469.67      -13469.67      -13553.824     -13553.824      325.68523      325.68523      31985.613      31985.613     -3260.2289     -3260.2289    
     34000  -13473.304     -13473.304     -13552.523     -13552.523      306.58729      306.58729      31933.378      31933.378      577.58986      577.58986    
Loop time of 598.56 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.267 hours/ns, 1.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.97     | 597.97     | 597.97     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1152     | 0.1152     | 0.1152     |   0.0 |  0.02
Output  | 0.00020726 | 0.00020726 | 0.00020726 |   0.0 |  0.00
Modify  | 0.41211    | 0.41211    | 0.41211    |   0.0 |  0.07
Other   |            | 0.06005    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4413 ave        4413 max        4413 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:       269856 ave      269856 max      269856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269856
Ave neighs/atom = 134.928
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 = 312.842333756294, Press = -2.11140075534597
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13473.304     -13473.304     -13552.523     -13552.523      306.58729      306.58729      31933.378      31933.378      577.58986      577.58986    
     35000  -13471.519     -13471.519     -13553.554     -13553.554      317.48255      317.48255      31921.149      31921.149      1750.5316      1750.5316    
Loop time of 601.542 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.095 hours/ns, 1.662 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 600.95     | 600.95     | 600.95     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11652    | 0.11652    | 0.11652    |   0.0 |  0.02
Output  | 0.00016422 | 0.00016422 | 0.00016422 |   0.0 |  0.00
Modify  | 0.41139    | 0.41139    | 0.41139    |   0.0 |  0.07
Other   |            | 0.05984    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4468 ave        4468 max        4468 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:       269986 ave      269986 max      269986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269986
Ave neighs/atom = 134.993
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 = 312.840336424213, Press = -0.963143001144245
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13471.519     -13471.519     -13553.554     -13553.554      317.48255      317.48255      31921.149      31921.149      1750.5316      1750.5316    
     36000  -13470.162     -13470.162     -13555.003     -13555.003      328.34365      328.34365      31943.865      31943.865     -282.23123     -282.23123    
Loop time of 602.216 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.282 hours/ns, 1.661 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 601.62     | 601.62     | 601.62     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11676    | 0.11676    | 0.11676    |   0.0 |  0.02
Output  | 0.00016516 | 0.00016516 | 0.00016516 |   0.0 |  0.00
Modify  | 0.41356    | 0.41356    | 0.41356    |   0.0 |  0.07
Other   |            | 0.06035    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4455 ave        4455 max        4455 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:       270042 ave      270042 max      270042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270042
Ave neighs/atom = 135.021
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 = 312.819155604269, Press = 0.160339676679009
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13470.162     -13470.162     -13555.003     -13555.003      328.34365      328.34365      31943.865      31943.865     -282.23123     -282.23123    
     37000  -13469.274     -13469.274     -13553.867     -13553.867      327.3835       327.3835       31950.854      31950.854     -615.35177     -615.35177    
Loop time of 602.432 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.342 hours/ns, 1.660 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 601.85     | 601.85     | 601.85     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11563    | 0.11563    | 0.11563    |   0.0 |  0.02
Output  | 0.00016322 | 0.00016322 | 0.00016322 |   0.0 |  0.00
Modify  | 0.41065    | 0.41065    | 0.41065    |   0.0 |  0.07
Other   |            | 0.06032    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4415 ave        4415 max        4415 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:       270050 ave      270050 max      270050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270050
Ave neighs/atom = 135.025
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 = 312.794765204731, Press = 0.242292939995167
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13469.274     -13469.274     -13553.867     -13553.867      327.3835       327.3835       31950.854      31950.854     -615.35177     -615.35177    
     38000  -13469.93      -13469.93      -13550.613     -13550.613      312.25452      312.25452      31960.059      31960.059     -1129.7577     -1129.7577    
Loop time of 592.825 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.673 hours/ns, 1.687 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 592.25     | 592.25     | 592.25     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11356    | 0.11356    | 0.11356    |   0.0 |  0.02
Output  | 0.0002069  | 0.0002069  | 0.0002069  |   0.0 |  0.00
Modify  | 0.40286    | 0.40286    | 0.40286    |   0.0 |  0.07
Other   |            | 0.05922    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4424 ave        4424 max        4424 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:       270034 ave      270034 max      270034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270034
Ave neighs/atom = 135.017
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 = 312.887118094302, Press = -1.93559478386588
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13469.93      -13469.93      -13550.613     -13550.613      312.25452      312.25452      31960.059      31960.059     -1129.7577     -1129.7577    
     39000  -13470.322     -13470.322     -13551.864     -13551.864      315.57472      315.57472      31911.449      31911.449      2328.3254      2328.3254    
Loop time of 596.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.793 hours/ns, 1.675 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.28     | 596.28     | 596.28     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11419    | 0.11419    | 0.11419    |   0.0 |  0.02
Output  | 0.00020919 | 0.00020919 | 0.00020919 |   0.0 |  0.00
Modify  | 0.40626    | 0.40626    | 0.40626    |   0.0 |  0.07
Other   |            | 0.05945    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4394 ave        4394 max        4394 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:       269728 ave      269728 max      269728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 269728
Ave neighs/atom = 134.864
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 = 312.910741022826, Press = -2.13997383621795
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13470.322     -13470.322     -13551.864     -13551.864      315.57472      315.57472      31911.449      31911.449      2328.3254      2328.3254    
     40000  -13472.146     -13472.146     -13556.382     -13556.382      326.0029       326.0029       31918.124      31918.124      1510.8214      1510.8214    
Loop time of 597.512 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.976 hours/ns, 1.674 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.92     | 596.92     | 596.92     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11639    | 0.11639    | 0.11639    |   0.0 |  0.02
Output  | 0.00021962 | 0.00021962 | 0.00021962 |   0.0 |  0.00
Modify  | 0.41081    | 0.41081    | 0.41081    |   0.0 |  0.07
Other   |            | 0.05992    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4463 ave        4463 max        4463 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:       270026 ave      270026 max      270026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270026
Ave neighs/atom = 135.013
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 = 312.959034789153, Press = 0.696806847099871
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.9
  ghost atom cutoff = 7.9
  binsize = 3.95, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.139 | 4.139 | 4.139 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13472.146     -13472.146     -13556.382     -13556.382      326.0029       326.0029       31918.124      31918.124      1510.8214      1510.8214    
     41000  -13467.554     -13467.554     -13548.94      -13548.94       314.97046      314.97046      31943.589      31943.589      475.90765      475.90765    
Loop time of 598.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.158 hours/ns, 1.672 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 597.58     | 597.58     | 597.58     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11624    | 0.11624    | 0.11624    |   0.0 |  0.02
Output  | 0.00016647 | 0.00016647 | 0.00016647 |   0.0 |  0.00
Modify  | 0.41441    | 0.41441    | 0.41441    |   0.0 |  0.07
Other   |            | 0.06036    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4440 ave        4440 max        4440 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:       270296 ave      270296 max      270296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 270296
Ave neighs/atom = 135.148
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
31941.0152901481

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0