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

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

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

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

kim_interactions Pb

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

kim interactions Pb
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimLee_2017_MgPb__MO_325675357262_002
pair_coeff * * Pb
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 207.2

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 121268.813318623 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_325675357262_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -7987.791      -7987.791      -8160          -8160           333.15         333.15         121268.81      121268.81      1516.7925      1516.7925    
      1000  -7787.2804     -7787.2804     -7968.686      -7968.686       350.94147      350.94147      124886.58      124886.58      81.44851       81.44851     
Loop time of 60.1008 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.438 ns/day, 16.695 hours/ns, 16.639 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.901     | 59.901     | 59.901     |   0.0 | 99.67
Neigh   | 0.045358   | 0.045358   | 0.045358   |   0.0 |  0.08
Comm    | 0.023086   | 0.023086   | 0.023086   |   0.0 |  0.04
Output  | 0.00016454 | 0.00016454 | 0.00016454 |   0.0 |  0.00
Modify  | 0.12007    | 0.12007    | 0.12007    |   0.0 |  0.20
Other   |            | 0.0109     |            |       |  0.02

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

Total # of neighbors = 278270
Ave neighs/atom = 69.5675
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -7787.2804     -7787.2804     -7968.686      -7968.686       350.94147      350.94147      124886.58      124886.58      81.44851       81.44851     
      2000  -7803.3843     -7803.3843     -7974.853      -7974.853       331.71781      331.71781      124892.2       124892.2      -282.73674     -282.73674    
Loop time of 58.9956 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.465 ns/day, 16.388 hours/ns, 16.950 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.8       | 58.8       | 58.8       |   0.0 | 99.67
Neigh   | 0.044748   | 0.044748   | 0.044748   |   0.0 |  0.08
Comm    | 0.022261   | 0.022261   | 0.022261   |   0.0 |  0.04
Output  | 6.1967e-05 | 6.1967e-05 | 6.1967e-05 |   0.0 |  0.00
Modify  | 0.11773    | 0.11773    | 0.11773    |   0.0 |  0.20
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 278404
Ave neighs/atom = 69.601
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -7803.3843     -7803.3843     -7974.853      -7974.853       331.71781      331.71781      124892.2       124892.2      -282.73674     -282.73674    
      3000  -7799.9548     -7799.9548     -7971.9465     -7971.9465      332.72944      332.72944      124919.75      124919.75     -143.55102     -143.55102    
Loop time of 59.1439 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.461 ns/day, 16.429 hours/ns, 16.908 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.949     | 58.949     | 58.949     |   0.0 | 99.67
Neigh   | 0.044625   | 0.044625   | 0.044625   |   0.0 |  0.08
Comm    | 0.022198   | 0.022198   | 0.022198   |   0.0 |  0.04
Output  | 5.898e-05  | 5.898e-05  | 5.898e-05  |   0.0 |  0.00
Modify  | 0.11786    | 0.11786    | 0.11786    |   0.0 |  0.20
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 279278
Ave neighs/atom = 69.8195
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -7799.9548     -7799.9548     -7971.9465     -7971.9465      332.72944      332.72944      124919.75      124919.75     -143.55102     -143.55102    
      4000  -7805.4482     -7805.4482     -7975.4703     -7975.4703      328.91917      328.91917      124808.8       124808.8       48.412781      48.412781    
Loop time of 59.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.458 ns/day, 16.465 hours/ns, 16.871 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.08      | 59.08      | 59.08      |   0.0 | 99.67
Neigh   | 0.044815   | 0.044815   | 0.044815   |   0.0 |  0.08
Comm    | 0.022253   | 0.022253   | 0.022253   |   0.0 |  0.04
Output  | 6.0323e-05 | 6.0323e-05 | 6.0323e-05 |   0.0 |  0.00
Modify  | 0.11774    | 0.11774    | 0.11774    |   0.0 |  0.20
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 279460
Ave neighs/atom = 69.865
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -7805.4482     -7805.4482     -7975.4703     -7975.4703      328.91917      328.91917      124808.8       124808.8       48.412781      48.412781    
      5000  -7798.0796     -7798.0796     -7974.5689     -7974.5689      341.43057      341.43057      124721.95      124721.95      456.8592       456.8592     
Loop time of 59.0052 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.464 ns/day, 16.390 hours/ns, 16.948 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.809     | 58.809     | 58.809     |   0.0 | 99.67
Neigh   | 0.044793   | 0.044793   | 0.044793   |   0.0 |  0.08
Comm    | 0.022306   | 0.022306   | 0.022306   |   0.0 |  0.04
Output  | 4.3411e-05 | 4.3411e-05 | 4.3411e-05 |   0.0 |  0.00
Modify  | 0.11832    | 0.11832    | 0.11832    |   0.0 |  0.20
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 279000
Ave neighs/atom = 69.75
Neighbor list builds = 4
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 = 339.609063932732, Press = -155.49439558709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -7798.0796     -7798.0796     -7974.5689     -7974.5689      341.43057      341.43057      124721.95      124721.95      456.8592       456.8592     
      6000  -7809.5326     -7809.5326     -7982.018      -7982.018       333.68484      333.68484      124721.12      124721.12     -38.434413     -38.434413    
Loop time of 59.3456 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.456 ns/day, 16.485 hours/ns, 16.850 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.146     | 59.146     | 59.146     |   0.0 | 99.66
Neigh   | 0.044961   | 0.044961   | 0.044961   |   0.0 |  0.08
Comm    | 0.022277   | 0.022277   | 0.022277   |   0.0 |  0.04
Output  | 4.5295e-05 | 4.5295e-05 | 4.5295e-05 |   0.0 |  0.00
Modify  | 0.12183    | 0.12183    | 0.12183    |   0.0 |  0.21
Other   |            | 0.01045    |            |       |  0.02

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

Total # of neighbors = 279866
Ave neighs/atom = 69.9665
Neighbor list builds = 4
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 = 333.784671801266, Press = -14.4650064337085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -7809.5326     -7809.5326     -7982.018      -7982.018       333.68484      333.68484      124721.12      124721.12     -38.434413     -38.434413    
      7000  -7808.5834     -7808.5834     -7979.2407     -7979.2407      330.148        330.148        124791.21      124791.21     -175.12364     -175.12364    
Loop time of 59.1996 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.459 ns/day, 16.444 hours/ns, 16.892 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59         | 59         | 59         |   0.0 | 99.66
Neigh   | 0.044721   | 0.044721   | 0.044721   |   0.0 |  0.08
Comm    | 0.022241   | 0.022241   | 0.022241   |   0.0 |  0.04
Output  | 4.5014e-05 | 4.5014e-05 | 4.5014e-05 |   0.0 |  0.00
Modify  | 0.12201    | 0.12201    | 0.12201    |   0.0 |  0.21
Other   |            | 0.0107     |            |       |  0.02

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

Total # of neighbors = 279588
Ave neighs/atom = 69.897
Neighbor list builds = 4
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 = 333.337596104006, Press = -1.17580749281858
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -7808.5834     -7808.5834     -7979.2407     -7979.2407      330.148        330.148        124791.21      124791.21     -175.12364     -175.12364    
      8000  -7807.6325     -7807.6325     -7980.9158     -7980.9158      335.22829      335.22829      124538.62      124538.62      670.49371      670.49371    
Loop time of 58.9566 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.465 ns/day, 16.377 hours/ns, 16.962 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.757     | 58.757     | 58.757     |   0.0 | 99.66
Neigh   | 0.044724   | 0.044724   | 0.044724   |   0.0 |  0.08
Comm    | 0.022179   | 0.022179   | 0.022179   |   0.0 |  0.04
Output  | 4.1588e-05 | 4.1588e-05 | 4.1588e-05 |   0.0 |  0.00
Modify  | 0.12173    | 0.12173    | 0.12173    |   0.0 |  0.21
Other   |            | 0.0105     |            |       |  0.02

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

Total # of neighbors = 280256
Ave neighs/atom = 70.064
Neighbor list builds = 4
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 = 333.274601526878, Press = 0.547547724711668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -7807.6325     -7807.6325     -7980.9158     -7980.9158      335.22829      335.22829      124538.62      124538.62      670.49371      670.49371    
      9000  -7811.1847     -7811.1847     -7983.3186     -7983.3186      333.00456      333.00456      124649.53      124649.53      161.77865      161.77865    
Loop time of 59.3379 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.456 ns/day, 16.483 hours/ns, 16.853 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.139     | 59.139     | 59.139     |   0.0 | 99.67
Neigh   | 0.044641   | 0.044641   | 0.044641   |   0.0 |  0.08
Comm    | 0.022052   | 0.022052   | 0.022052   |   0.0 |  0.04
Output  | 4.3432e-05 | 4.3432e-05 | 4.3432e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.20
Other   |            | 0.01048    |            |       |  0.02

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

Total # of neighbors = 280424
Ave neighs/atom = 70.106
Neighbor list builds = 4
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 = 333.19548961972, Press = -3.18297062044974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -7811.1847     -7811.1847     -7983.3186     -7983.3186      333.00456      333.00456      124649.53      124649.53      161.77865      161.77865    
     10000  -7803.7227     -7803.7227     -7979.8202     -7979.8202      340.67253      340.67253      124771         124771        -57.408941     -57.408941    
Loop time of 59.1025 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.462 ns/day, 16.417 hours/ns, 16.920 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.915     | 58.915     | 58.915     |   0.0 | 99.68
Neigh   | 0.033587   | 0.033587   | 0.033587   |   0.0 |  0.06
Comm    | 0.022011   | 0.022011   | 0.022011   |   0.0 |  0.04
Output  | 4.5756e-05 | 4.5756e-05 | 4.5756e-05 |   0.0 |  0.00
Modify  | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.21
Other   |            | 0.01057    |            |       |  0.02

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

Total # of neighbors = 279140
Ave neighs/atom = 69.785
Neighbor list builds = 3
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 = 333.583079173187, Press = -3.69658723845149
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -7803.7227     -7803.7227     -7979.8202     -7979.8202      340.67253      340.67253      124771         124771        -57.408941     -57.408941    
     11000  -7801.0628     -7801.0628     -7981.6057     -7981.6057      349.27257      349.27257      124813.57      124813.57     -379.84831     -379.84831    
Loop time of 59.1835 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.460 ns/day, 16.440 hours/ns, 16.897 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.984     | 58.984     | 58.984     |   0.0 | 99.66
Neigh   | 0.044818   | 0.044818   | 0.044818   |   0.0 |  0.08
Comm    | 0.022118   | 0.022118   | 0.022118   |   0.0 |  0.04
Output  | 4.26e-05   | 4.26e-05   | 4.26e-05   |   0.0 |  0.00
Modify  | 0.1222     | 0.1222     | 0.1222     |   0.0 |  0.21
Other   |            | 0.01049    |            |       |  0.02

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

Total # of neighbors = 279230
Ave neighs/atom = 69.8075
Neighbor list builds = 4
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 = 333.666675780127, Press = -8.50716639564457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -7801.0628     -7801.0628     -7981.6057     -7981.6057      349.27257      349.27257      124813.57      124813.57     -379.84831     -379.84831    
     12000  -7804.9552     -7804.9552     -7977.3813     -7977.3813      333.56994      333.56994      124900.39      124900.39     -409.49308     -409.49308    
Loop time of 59.1905 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.460 ns/day, 16.442 hours/ns, 16.895 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.992     | 58.992     | 58.992     |   0.0 | 99.66
Neigh   | 0.044814   | 0.044814   | 0.044814   |   0.0 |  0.08
Comm    | 0.022028   | 0.022028   | 0.022028   |   0.0 |  0.04
Output  | 4.3562e-05 | 4.3562e-05 | 4.3562e-05 |   0.0 |  0.00
Modify  | 0.12142    | 0.12142    | 0.12142    |   0.0 |  0.21
Other   |            | 0.01052    |            |       |  0.02

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

Total # of neighbors = 279558
Ave neighs/atom = 69.8895
Neighbor list builds = 4
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 = 333.835756594167, Press = -2.49129772177008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -7804.9552     -7804.9552     -7977.3813     -7977.3813      333.56994      333.56994      124900.39      124900.39     -409.49308     -409.49308    
     13000  -7804.1457     -7804.1457     -7978.1375     -7978.1375      336.5989       336.5989       124801.27      124801.27     -139.08337     -139.08337    
Loop time of 59.0773 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.462 ns/day, 16.410 hours/ns, 16.927 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.89      | 58.89      | 58.89      |   0.0 | 99.68
Neigh   | 0.033569   | 0.033569   | 0.033569   |   0.0 |  0.06
Comm    | 0.02198    | 0.02198    | 0.02198    |   0.0 |  0.04
Output  | 4.5385e-05 | 4.5385e-05 | 4.5385e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.21
Other   |            | 0.01061    |            |       |  0.02

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

Total # of neighbors = 278594
Ave neighs/atom = 69.6485
Neighbor list builds = 3
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 = 333.750717814032, Press = -1.29322121215147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -7804.1457     -7804.1457     -7978.1375     -7978.1375      336.5989       336.5989       124801.27      124801.27     -139.08337     -139.08337    
     14000  -7801.073      -7801.073      -7976.2839     -7976.2839      338.9573       338.9573       124766.53      124766.53      179.98369      179.98369    
Loop time of 59.1509 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.461 ns/day, 16.431 hours/ns, 16.906 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.951     | 58.951     | 58.951     |   0.0 | 99.66
Neigh   | 0.044817   | 0.044817   | 0.044817   |   0.0 |  0.08
Comm    | 0.022073   | 0.022073   | 0.022073   |   0.0 |  0.04
Output  | 8.4098e-05 | 8.4098e-05 | 8.4098e-05 |   0.0 |  0.00
Modify  | 0.12213    | 0.12213    | 0.12213    |   0.0 |  0.21
Other   |            | 0.01059    |            |       |  0.02

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

Total # of neighbors = 279344
Ave neighs/atom = 69.836
Neighbor list builds = 4
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 = 333.831500778662, Press = -1.27245794069344
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -7801.073      -7801.073      -7976.2839     -7976.2839      338.9573       338.9573       124766.53      124766.53      179.98369      179.98369    
     15000  -7810.8404     -7810.8404     -7984.5057     -7984.5057      335.96737      335.96737      124553.27      124553.27      436.83806      436.83806    
Loop time of 59.1607 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.460 ns/day, 16.434 hours/ns, 16.903 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.973     | 58.973     | 58.973     |   0.0 | 99.68
Neigh   | 0.033618   | 0.033618   | 0.033618   |   0.0 |  0.06
Comm    | 0.021969   | 0.021969   | 0.021969   |   0.0 |  0.04
Output  | 4.4283e-05 | 4.4283e-05 | 4.4283e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.21
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 279850
Ave neighs/atom = 69.9625
Neighbor list builds = 3
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 = 333.793538612187, Press = -2.6382953925939
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -7810.8404     -7810.8404     -7984.5057     -7984.5057      335.96737      335.96737      124553.27      124553.27      436.83806      436.83806    
     16000  -7810.7821     -7810.7821     -7982.6914     -7982.6914      332.57024      332.57024      124662.46      124662.46      84.068089      84.068089    
Loop time of 59.172 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.460 ns/day, 16.437 hours/ns, 16.900 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.973     | 58.973     | 58.973     |   0.0 | 99.66
Neigh   | 0.044831   | 0.044831   | 0.044831   |   0.0 |  0.08
Comm    | 0.021971   | 0.021971   | 0.021971   |   0.0 |  0.04
Output  | 4.4093e-05 | 4.4093e-05 | 4.4093e-05 |   0.0 |  0.00
Modify  | 0.1213     | 0.1213     | 0.1213     |   0.0 |  0.20
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 279648
Ave neighs/atom = 69.912
Neighbor list builds = 4
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 = 333.686160615776, Press = -3.55890688685602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -7810.7821     -7810.7821     -7982.6914     -7982.6914      332.57024      332.57024      124662.46      124662.46      84.068089      84.068089    
     17000  -7810.6276     -7810.6276     -7984.975      -7984.975       337.28697      337.28697      124698.96      124698.96     -156.70574     -156.70574    
Loop time of 59.2061 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.459 ns/day, 16.446 hours/ns, 16.890 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.007     | 59.007     | 59.007     |   0.0 | 99.66
Neigh   | 0.04481    | 0.04481    | 0.04481    |   0.0 |  0.08
Comm    | 0.022053   | 0.022053   | 0.022053   |   0.0 |  0.04
Output  | 4.1368e-05 | 4.1368e-05 | 4.1368e-05 |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  0.20
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 279932
Ave neighs/atom = 69.983
Neighbor list builds = 4
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 = 333.76731689113, Press = -1.35799682031655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -7810.6276     -7810.6276     -7984.975      -7984.975       337.28697      337.28697      124698.96      124698.96     -156.70574     -156.70574    
     18000  -7810.7146     -7810.7146     -7980.6642     -7980.6642      328.77897      328.77897      124784.03      124784.03     -268.04751     -268.04751    
Loop time of 59.2846 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.457 ns/day, 16.468 hours/ns, 16.868 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.086     | 59.086     | 59.086     |   0.0 | 99.67
Neigh   | 0.044857   | 0.044857   | 0.044857   |   0.0 |  0.08
Comm    | 0.022043   | 0.022043   | 0.022043   |   0.0 |  0.04
Output  | 4.1919e-05 | 4.1919e-05 | 4.1919e-05 |   0.0 |  0.00
Modify  | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.20
Other   |            | 0.01045    |            |       |  0.02

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

Total # of neighbors = 279606
Ave neighs/atom = 69.9015
Neighbor list builds = 4
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 = 333.709541707622, Press = -0.919221507601914
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -7810.7146     -7810.7146     -7980.6642     -7980.6642      328.77897      328.77897      124784.03      124784.03     -268.04751     -268.04751    
     19000  -7806.7556     -7806.7556     -7980.4765     -7980.4765      336.07498      336.07498      124712.36      124712.36      46.583157      46.583157    
Loop time of 59.2019 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.459 ns/day, 16.445 hours/ns, 16.891 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.003     | 59.003     | 59.003     |   0.0 | 99.66
Neigh   | 0.044792   | 0.044792   | 0.044792   |   0.0 |  0.08
Comm    | 0.022046   | 0.022046   | 0.022046   |   0.0 |  0.04
Output  | 4.2369e-05 | 4.2369e-05 | 4.2369e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.20
Other   |            | 0.0106     |            |       |  0.02

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

Total # of neighbors = 279114
Ave neighs/atom = 69.7785
Neighbor list builds = 4
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 = 333.58981344273, Press = -1.64105947707013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -7806.7556     -7806.7556     -7980.4765     -7980.4765      336.07498      336.07498      124712.36      124712.36      46.583157      46.583157    
     20000  -7802.8458     -7802.8458     -7978.5676     -7978.5676      339.94584      339.94584      124866.95      124866.95     -264.65038     -264.65038    
Loop time of 59.374 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.455 ns/day, 16.493 hours/ns, 16.842 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.175     | 59.175     | 59.175     |   0.0 | 99.66
Neigh   | 0.044903   | 0.044903   | 0.044903   |   0.0 |  0.08
Comm    | 0.021963   | 0.021963   | 0.021963   |   0.0 |  0.04
Output  | 4.2149e-05 | 4.2149e-05 | 4.2149e-05 |   0.0 |  0.00
Modify  | 0.12194    | 0.12194    | 0.12194    |   0.0 |  0.21
Other   |            | 0.01061    |            |       |  0.02

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

Total # of neighbors = 279284
Ave neighs/atom = 69.821
Neighbor list builds = 4
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 = 333.540414244779, Press = -1.30261426449614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -7802.8458     -7802.8458     -7978.5676     -7978.5676      339.94584      339.94584      124866.95      124866.95     -264.65038     -264.65038    
     21000  -7807.1644     -7807.1644     -7980.4696     -7980.4696      335.27067      335.27067      124619.36      124619.36      387.53922      387.53922    
Loop time of 59.188 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.460 ns/day, 16.441 hours/ns, 16.895 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.99      | 58.99      | 58.99      |   0.0 | 99.66
Neigh   | 0.044722   | 0.044722   | 0.044722   |   0.0 |  0.08
Comm    | 0.021973   | 0.021973   | 0.021973   |   0.0 |  0.04
Output  | 4.2109e-05 | 4.2109e-05 | 4.2109e-05 |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  0.21
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 278952
Ave neighs/atom = 69.738
Neighbor list builds = 4
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 = 333.593264327652, Press = -1.67449327874952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -7807.1644     -7807.1644     -7980.4696     -7980.4696      335.27067      335.27067      124619.36      124619.36      387.53922      387.53922    
     22000  -7808.7561     -7808.7561     -7980.7145     -7980.7145      332.66528      332.66528      124701.17      124701.17      88.329715      88.329715    
Loop time of 59.2268 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.459 ns/day, 16.452 hours/ns, 16.884 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.028     | 59.028     | 59.028     |   0.0 | 99.66
Neigh   | 0.044947   | 0.044947   | 0.044947   |   0.0 |  0.08
Comm    | 0.022115   | 0.022115   | 0.022115   |   0.0 |  0.04
Output  | 4.3211e-05 | 4.3211e-05 | 4.3211e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.20
Other   |            | 0.01054    |            |       |  0.02

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

Total # of neighbors = 279364
Ave neighs/atom = 69.841
Neighbor list builds = 4
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 = 333.608452469758, Press = -1.07287437065617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -7808.7561     -7808.7561     -7980.7145     -7980.7145      332.66528      332.66528      124701.17      124701.17      88.329715      88.329715    
     23000  -7804.7259     -7804.7259     -7978.8458     -7978.8458      336.84676      336.84676      124886.15      124886.15     -435.293       -435.293      
Loop time of 59.5284 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.451 ns/day, 16.536 hours/ns, 16.799 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.329     | 59.329     | 59.329     |   0.0 | 99.67
Neigh   | 0.044951   | 0.044951   | 0.044951   |   0.0 |  0.08
Comm    | 0.021999   | 0.021999   | 0.021999   |   0.0 |  0.04
Output  | 4.1017e-05 | 4.1017e-05 | 4.1017e-05 |   0.0 |  0.00
Modify  | 0.12204    | 0.12204    | 0.12204    |   0.0 |  0.21
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 279528
Ave neighs/atom = 69.882
Neighbor list builds = 4
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 = 333.595153961079, Press = -1.14510526921001
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -7804.7259     -7804.7259     -7978.8458     -7978.8458      336.84676      336.84676      124886.15      124886.15     -435.293       -435.293      
     24000  -7808.9719     -7808.9719     -7982.0736     -7982.0736      334.87692      334.87692      124856.05      124856.05     -522.04839     -522.04839    
Loop time of 59.293 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.457 ns/day, 16.470 hours/ns, 16.865 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.094     | 59.094     | 59.094     |   0.0 | 99.66
Neigh   | 0.044813   | 0.044813   | 0.044813   |   0.0 |  0.08
Comm    | 0.022051   | 0.022051   | 0.022051   |   0.0 |  0.04
Output  | 4.2881e-05 | 4.2881e-05 | 4.2881e-05 |   0.0 |  0.00
Modify  | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

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

Total # of neighbors = 279892
Ave neighs/atom = 69.973
Neighbor list builds = 4
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 = 333.638621950634, Press = -1.73150049320394
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -7808.9719     -7808.9719     -7982.0736     -7982.0736      334.87692      334.87692      124856.05      124856.05     -522.04839     -522.04839    
     25000  -7807.391      -7807.391      -7982.4551     -7982.4551      338.67337      338.67337      124720.03      124720.03      11.730919      11.730919    
Loop time of 59.3705 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.455 ns/day, 16.492 hours/ns, 16.843 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.183     | 59.183     | 59.183     |   0.0 | 99.68
Neigh   | 0.033522   | 0.033522   | 0.033522   |   0.0 |  0.06
Comm    | 0.022058   | 0.022058   | 0.022058   |   0.0 |  0.04
Output  | 4.5385e-05 | 4.5385e-05 | 4.5385e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.20
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 280076
Ave neighs/atom = 70.019
Neighbor list builds = 3
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 = 333.570385656439, Press = -1.19956047224641
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -7807.391      -7807.391      -7982.4551     -7982.4551      338.67337      338.67337      124720.03      124720.03      11.730919      11.730919    
     26000  -7807.0315     -7807.0315     -7978.5598     -7978.5598      331.83312      331.83312      124821.27      124821.27     -156.99538     -156.99538    
Loop time of 59.3146 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.457 ns/day, 16.476 hours/ns, 16.859 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.116     | 59.116     | 59.116     |   0.0 | 99.67
Neigh   | 0.044697   | 0.044697   | 0.044697   |   0.0 |  0.08
Comm    | 0.021963   | 0.021963   | 0.021963   |   0.0 |  0.04
Output  | 4.1258e-05 | 4.1258e-05 | 4.1258e-05 |   0.0 |  0.00
Modify  | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.20
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 278952
Ave neighs/atom = 69.738
Neighbor list builds = 4
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 = 333.520454466722, Press = -1.40746460267698
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -7807.0315     -7807.0315     -7978.5598     -7978.5598      331.83312      331.83312      124821.27      124821.27     -156.99538     -156.99538    
     27000  -7812.4743     -7812.4743     -7981.4599     -7981.4599      326.914        326.914        124851.23      124851.23     -562.90822     -562.90822    
Loop time of 59.3458 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.456 ns/day, 16.485 hours/ns, 16.850 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.147     | 59.147     | 59.147     |   0.0 | 99.66
Neigh   | 0.044961   | 0.044961   | 0.044961   |   0.0 |  0.08
Comm    | 0.022296   | 0.022296   | 0.022296   |   0.0 |  0.04
Output  | 4.2239e-05 | 4.2239e-05 | 4.2239e-05 |   0.0 |  0.00
Modify  | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.20
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 279582
Ave neighs/atom = 69.8955
Neighbor list builds = 4
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 = 333.442811495715, Press = -0.802438496754079
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -7812.4743     -7812.4743     -7981.4599     -7981.4599      326.914        326.914        124851.23      124851.23     -562.90822     -562.90822    
     28000  -7810.5489     -7810.5489     -7982.4165     -7982.4165      332.48954      332.48954      124827.07      124827.07     -492.20632     -492.20632    
Loop time of 59.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.458 ns/day, 16.456 hours/ns, 16.880 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.045     | 59.045     | 59.045     |   0.0 | 99.66
Neigh   | 0.044564   | 0.044564   | 0.044564   |   0.0 |  0.08
Comm    | 0.022119   | 0.022119   | 0.022119   |   0.0 |  0.04
Output  | 4.3992e-05 | 4.3992e-05 | 4.3992e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.20
Other   |            | 0.01055    |            |       |  0.02

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

Total # of neighbors = 280306
Ave neighs/atom = 70.0765
Neighbor list builds = 4
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 = 333.442130318343, Press = -1.18665908102847
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -7810.5489     -7810.5489     -7982.4165     -7982.4165      332.48954      332.48954      124827.07      124827.07     -492.20632     -492.20632    
     29000  -7805.8678     -7805.8678     -7980.6829     -7980.6829      338.19156      338.19156      124855.19      124855.19     -376.5085      -376.5085     
Loop time of 59.2205 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.459 ns/day, 16.450 hours/ns, 16.886 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.021     | 59.021     | 59.021     |   0.0 | 99.66
Neigh   | 0.044754   | 0.044754   | 0.044754   |   0.0 |  0.08
Comm    | 0.022044   | 0.022044   | 0.022044   |   0.0 |  0.04
Output  | 4.1729e-05 | 4.1729e-05 | 4.1729e-05 |   0.0 |  0.00
Modify  | 0.12204    | 0.12204    | 0.12204    |   0.0 |  0.21
Other   |            | 0.01054    |            |       |  0.02

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

Total # of neighbors = 279850
Ave neighs/atom = 69.9625
Neighbor list builds = 4
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 = 333.399622582473, Press = -0.261772013285615
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -7805.8678     -7805.8678     -7980.6829     -7980.6829      338.19156      338.19156      124855.19      124855.19     -376.5085      -376.5085     
     30000  -7805.4368     -7805.4368     -7978.51       -7978.51        334.82185      334.82185      124833.55      124833.55     -229.81516     -229.81516    
Loop time of 59.3441 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.456 ns/day, 16.484 hours/ns, 16.851 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.145     | 59.145     | 59.145     |   0.0 | 99.67
Neigh   | 0.044807   | 0.044807   | 0.044807   |   0.0 |  0.08
Comm    | 0.022315   | 0.022315   | 0.022315   |   0.0 |  0.04
Output  | 4.2279e-05 | 4.2279e-05 | 4.2279e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.20
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 279786
Ave neighs/atom = 69.9465
Neighbor list builds = 4
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 = 333.423975022736, Press = 0.295437712879358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -7805.4368     -7805.4368     -7978.51       -7978.51        334.82185      334.82185      124833.55      124833.55     -229.81516     -229.81516    
     31000  -7800.0564     -7800.0564     -7977.9793     -7977.9793      344.20385      344.20385      124777.29      124777.29      110.76967      110.76967    
Loop time of 59.3559 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.456 ns/day, 16.488 hours/ns, 16.848 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.157     | 59.157     | 59.157     |   0.0 | 99.67
Neigh   | 0.044789   | 0.044789   | 0.044789   |   0.0 |  0.08
Comm    | 0.022178   | 0.022178   | 0.022178   |   0.0 |  0.04
Output  | 4.24e-05   | 4.24e-05   | 4.24e-05   |   0.0 |  0.00
Modify  | 0.12102    | 0.12102    | 0.12102    |   0.0 |  0.20
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 279570
Ave neighs/atom = 69.8925
Neighbor list builds = 4
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 = 333.477312957217, Press = 0.399083746060978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -7800.0564     -7800.0564     -7977.9793     -7977.9793      344.20385      344.20385      124777.29      124777.29      110.76967      110.76967    
     32000  -7806.5206     -7806.5206     -7977.7519     -7977.7519      331.25862      331.25862      124766.2       124766.2       72.93419       72.93419     
Loop time of 59.3545 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.456 ns/day, 16.487 hours/ns, 16.848 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.155     | 59.155     | 59.155     |   0.0 | 99.66
Neigh   | 0.044824   | 0.044824   | 0.044824   |   0.0 |  0.08
Comm    | 0.021969   | 0.021969   | 0.021969   |   0.0 |  0.04
Output  | 4.2329e-05 | 4.2329e-05 | 4.2329e-05 |   0.0 |  0.00
Modify  | 0.12193    | 0.12193    | 0.12193    |   0.0 |  0.21
Other   |            | 0.01038    |            |       |  0.02

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

Total # of neighbors = 279698
Ave neighs/atom = 69.9245
Neighbor list builds = 4
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 = 333.397010789634, Press = 0.182917462071188
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -7806.5206     -7806.5206     -7977.7519     -7977.7519      331.25862      331.25862      124766.2       124766.2       72.93419       72.93419     
     33000  -7804.7693     -7804.7693     -7976.4684     -7976.4684      332.1636       332.1636       124776.88      124776.88      87.467967      87.467967    
Loop time of 59.3347 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.456 ns/day, 16.482 hours/ns, 16.854 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.136     | 59.136     | 59.136     |   0.0 | 99.67
Neigh   | 0.044778   | 0.044778   | 0.044778   |   0.0 |  0.08
Comm    | 0.022112   | 0.022112   | 0.022112   |   0.0 |  0.04
Output  | 4.1849e-05 | 4.1849e-05 | 4.1849e-05 |   0.0 |  0.00
Modify  | 0.12102    | 0.12102    | 0.12102    |   0.0 |  0.20
Other   |            | 0.01045    |            |       |  0.02

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

Total # of neighbors = 279504
Ave neighs/atom = 69.876
Neighbor list builds = 4
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
124756.087083021

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0