# 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.9173715263605122*${_u_distance}
variable latticeconst_converted equal 3.9173715263605122*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.91737152636051
Lattice spacing in x,y,z = 3.9173715 3.9173715 3.9173715
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (39.173715 39.173715 39.173715)
  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 (39.173715 39.173715 39.173715)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtAl__MO_793141037706_002
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -22928.467     -22928.467     -23080         -23080          293.15         293.15         60115.199      60115.199      2692.3989      2692.3989    
      1000  -22768.752     -22768.752     -22929.582     -22929.582      311.13782      311.13782      60647.371      60647.371     -89.207769     -89.207769    
Loop time of 67.2146 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.285 ns/day, 18.671 hours/ns, 14.878 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    | 67.049     | 67.049     | 67.049     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030729   | 0.030729   | 0.030729   |   0.0 |  0.05
Output  | 0.0001839  | 0.0001839  | 0.0001839  |   0.0 |  0.00
Modify  | 0.12208    | 0.12208    | 0.12208    |   0.0 |  0.18
Other   |            | 0.01289    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       560000 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.208 ns/day, 19.863 hours/ns, 13.985 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    | 71.346     | 71.346     | 71.346     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029275   | 0.029275   | 0.029275   |   0.0 |  0.04
Output  | 7.3699e-05 | 7.3699e-05 | 7.3699e-05 |   0.0 |  0.00
Modify  | 0.11869    | 0.11869    | 0.11869    |   0.0 |  0.17
Other   |            | 0.01179    |            |       |  0.02

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

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

Performance: 1.204 ns/day, 19.933 hours/ns, 13.936 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    | 71.6       | 71.6       | 71.6       |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029118   | 0.029118   | 0.029118   |   0.0 |  0.04
Output  | 7.6204e-05 | 7.6204e-05 | 7.6204e-05 |   0.0 |  0.00
Modify  | 0.11834    | 0.11834    | 0.11834    |   0.0 |  0.16
Other   |            | 0.0116     |            |       |  0.02

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

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

Performance: 1.205 ns/day, 19.909 hours/ns, 13.952 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    | 71.514     | 71.514     | 71.514     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029162   | 0.029162   | 0.029162   |   0.0 |  0.04
Output  | 0.00010307 | 0.00010307 | 0.00010307 |   0.0 |  0.00
Modify  | 0.11837    | 0.11837    | 0.11837    |   0.0 |  0.17
Other   |            | 0.01164    |            |       |  0.02

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

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

Performance: 1.203 ns/day, 19.951 hours/ns, 13.923 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    | 71.664     | 71.664     | 71.664     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029476   | 0.029476   | 0.029476   |   0.0 |  0.04
Output  | 6.4591e-05 | 6.4591e-05 | 6.4591e-05 |   0.0 |  0.00
Modify  | 0.11905    | 0.11905    | 0.11905    |   0.0 |  0.17
Other   |            | 0.01175    |            |       |  0.02

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

Total # of neighbors = 559046
Ave neighs/atom = 139.7615
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 = 296.183636087725, Press = 188.057698928143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -22778.839     -22778.839     -22927.907     -22927.907      288.38119      288.38119      60654.154      60654.154     -502.07911     -502.07911    
      6000  -22778.061     -22778.061     -22931.269     -22931.269      296.39024      296.39024      60633.757      60633.757      136.73192      136.73192    
Loop time of 71.898 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.972 hours/ns, 13.909 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    | 71.734     | 71.734     | 71.734     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029235   | 0.029235   | 0.029235   |   0.0 |  0.04
Output  | 5.819e-05  | 5.819e-05  | 5.819e-05  |   0.0 |  0.00
Modify  | 0.12309    | 0.12309    | 0.12309    |   0.0 |  0.17
Other   |            | 0.01176    |            |       |  0.02

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

Total # of neighbors = 558728
Ave neighs/atom = 139.682
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 = 293.579278644502, Press = 49.0079367791214
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -22778.061     -22778.061     -22931.269     -22931.269      296.39024      296.39024      60633.757      60633.757      136.73192      136.73192    
      7000  -22775.928     -22775.928     -22927.187     -22927.187      292.62024      292.62024      60613.362      60613.362      1571.155       1571.155     
Loop time of 71.7077 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.205 ns/day, 19.919 hours/ns, 13.946 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    | 71.544     | 71.544     | 71.544     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029165   | 0.029165   | 0.029165   |   0.0 |  0.04
Output  | 3.7861e-05 | 3.7861e-05 | 3.7861e-05 |   0.0 |  0.00
Modify  | 0.12302    | 0.12302    | 0.12302    |   0.0 |  0.17
Other   |            | 0.01173    |            |       |  0.02

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

Total # of neighbors = 558924
Ave neighs/atom = 139.731
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 = 293.010404600681, Press = 18.8567062544873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -22775.928     -22775.928     -22927.187     -22927.187      292.62024      292.62024      60613.362      60613.362      1571.155       1571.155     
      8000  -22777.617     -22777.617     -22928.377     -22928.377      291.65423      291.65423      60638.935      60638.935      349.27568      349.27568    
Loop time of 71.81 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.947 hours/ns, 13.926 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    | 71.646     | 71.646     | 71.646     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02917    | 0.02917    | 0.02917    |   0.0 |  0.04
Output  | 5.7298e-05 | 5.7298e-05 | 5.7298e-05 |   0.0 |  0.00
Modify  | 0.12304    | 0.12304    | 0.12304    |   0.0 |  0.17
Other   |            | 0.01179    |            |       |  0.02

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

Total # of neighbors = 558822
Ave neighs/atom = 139.7055
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 = 293.339273844992, Press = 4.4099023821434
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -22777.617     -22777.617     -22928.377     -22928.377      291.65423      291.65423      60638.935      60638.935      349.27568      349.27568    
      9000  -22779.149     -22779.149     -22931.341     -22931.341      294.42598      294.42598      60623.183      60623.183      608.21968      608.21968    
Loop time of 71.8639 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.962 hours/ns, 13.915 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    | 71.7       | 71.7       | 71.7       |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029152   | 0.029152   | 0.029152   |   0.0 |  0.04
Output  | 5.6577e-05 | 5.6577e-05 | 5.6577e-05 |   0.0 |  0.00
Modify  | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.17
Other   |            | 0.01174    |            |       |  0.02

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

Total # of neighbors = 558852
Ave neighs/atom = 139.713
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 = 293.080791188394, Press = 18.4693987251175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -22779.149     -22779.149     -22931.341     -22931.341      294.42598      294.42598      60623.183      60623.183      608.21968      608.21968    
     10000  -22776.631     -22776.631     -22927.23      -22927.23       291.34377      291.34377      60626.95       60626.95       958.33781      958.33781    
Loop time of 71.8037 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.945 hours/ns, 13.927 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    | 71.64      | 71.64      | 71.64      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029153   | 0.029153   | 0.029153   |   0.0 |  0.04
Output  | 5.814e-05  | 5.814e-05  | 5.814e-05  |   0.0 |  0.00
Modify  | 0.123      | 0.123      | 0.123      |   0.0 |  0.17
Other   |            | 0.01176    |            |       |  0.02

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

Total # of neighbors = 558910
Ave neighs/atom = 139.7275
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 = 293.264868192366, Press = 9.7317946276327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -22776.631     -22776.631     -22927.23      -22927.23       291.34377      291.34377      60626.95       60626.95       958.33781      958.33781    
     11000  -22777.835     -22777.835     -22930.387     -22930.387      295.12375      295.12375      60637.167      60637.167      161.02731      161.02731    
Loop time of 71.7737 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.937 hours/ns, 13.933 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    | 71.61      | 71.61      | 71.61      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029203   | 0.029203   | 0.029203   |   0.0 |  0.04
Output  | 5.5915e-05 | 5.5915e-05 | 5.5915e-05 |   0.0 |  0.00
Modify  | 0.12293    | 0.12293    | 0.12293    |   0.0 |  0.17
Other   |            | 0.01176    |            |       |  0.02

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

Total # of neighbors = 558836
Ave neighs/atom = 139.709
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 = 293.201583442789, Press = 0.566790502847631
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -22777.835     -22777.835     -22930.387     -22930.387      295.12375      295.12375      60637.167      60637.167      161.02731      161.02731    
     12000  -22779.929     -22779.929     -22928.448     -22928.448      287.31861      287.31861      60655.676      60655.676     -495.33214     -495.33214    
Loop time of 71.7097 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.205 ns/day, 19.919 hours/ns, 13.945 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 71.546     | 71.546     | 71.546     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029288   | 0.029288   | 0.029288   |   0.0 |  0.04
Output  | 5.8179e-05 | 5.8179e-05 | 5.8179e-05 |   0.0 |  0.00
Modify  | 0.12283    | 0.12283    | 0.12283    |   0.0 |  0.17
Other   |            | 0.01169    |            |       |  0.02

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

Total # of neighbors = 558790
Ave neighs/atom = 139.6975
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 = 293.068926940466, Press = 0.602580422313223
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -22779.929     -22779.929     -22928.448     -22928.448      287.31861      287.31861      60655.676      60655.676     -495.33214     -495.33214    
     13000  -22775.11      -22775.11      -22929.727     -22929.727      299.11847      299.11847      60666.323      60666.323     -1107.681      -1107.681     
Loop time of 71.8283 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.952 hours/ns, 13.922 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 71.664     | 71.664     | 71.664     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029245   | 0.029245   | 0.029245   |   0.0 |  0.04
Output  | 6.0363e-05 | 6.0363e-05 | 6.0363e-05 |   0.0 |  0.00
Modify  | 0.12314    | 0.12314    | 0.12314    |   0.0 |  0.17
Other   |            | 0.01169    |            |       |  0.02

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

Total # of neighbors = 558868
Ave neighs/atom = 139.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 = 292.884102550513, Press = 2.96777877784799
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -22775.11      -22775.11      -22929.727     -22929.727      299.11847      299.11847      60666.323      60666.323     -1107.681      -1107.681     
     14000  -22778.571     -22778.571     -22932.351     -22932.351      297.49799      297.49799      60641.23       60641.23      -319.96831     -319.96831    
Loop time of 71.9419 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.984 hours/ns, 13.900 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    | 71.778     | 71.778     | 71.778     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029136   | 0.029136   | 0.029136   |   0.0 |  0.04
Output  | 9.547e-05  | 9.547e-05  | 9.547e-05  |   0.0 |  0.00
Modify  | 0.12316    | 0.12316    | 0.12316    |   0.0 |  0.17
Other   |            | 0.01175    |            |       |  0.02

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

Total # of neighbors = 558744
Ave neighs/atom = 139.686
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 = 292.896753824482, Press = 3.41144645152241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -22778.571     -22778.571     -22932.351     -22932.351      297.49799      297.49799      60641.23       60641.23      -319.96831     -319.96831    
     15000  -22778.592     -22778.592     -22928.738     -22928.738      290.46751      290.46751      60631.113      60631.113      654.35817      654.35817    
Loop time of 71.8762 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.966 hours/ns, 13.913 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    | 71.712     | 71.712     | 71.712     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029126   | 0.029126   | 0.029126   |   0.0 |  0.04
Output  | 6.1556e-05 | 6.1556e-05 | 6.1556e-05 |   0.0 |  0.00
Modify  | 0.12316    | 0.12316    | 0.12316    |   0.0 |  0.17
Other   |            | 0.01171    |            |       |  0.02

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

Total # of neighbors = 559004
Ave neighs/atom = 139.751
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 = 292.752243149722, Press = 3.4777635414595
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -22778.592     -22778.592     -22928.738     -22928.738      290.46751      290.46751      60631.113      60631.113      654.35817      654.35817    
     16000  -22777.279     -22777.279     -22928.028     -22928.028      291.6332       291.6332       60595.84       60595.84       2296.3936      2296.3936    
Loop time of 71.7009 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.205 ns/day, 19.917 hours/ns, 13.947 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    | 71.537     | 71.537     | 71.537     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0293     | 0.0293     | 0.0293     |   0.0 |  0.04
Output  | 6.0384e-05 | 6.0384e-05 | 6.0384e-05 |   0.0 |  0.00
Modify  | 0.12311    | 0.12311    | 0.12311    |   0.0 |  0.17
Other   |            | 0.01172    |            |       |  0.02

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

Total # of neighbors = 558866
Ave neighs/atom = 139.7165
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 = 292.763247957836, Press = 4.78511396839017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -22777.279     -22777.279     -22928.028     -22928.028      291.6332       291.6332       60595.84       60595.84       2296.3936      2296.3936    
     17000  -22778.181     -22778.181     -22931.071     -22931.071      295.7754       295.7754       60592.192      60592.192      2039.0784      2039.0784    
Loop time of 71.9167 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.977 hours/ns, 13.905 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    | 71.752     | 71.752     | 71.752     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029325   | 0.029325   | 0.029325   |   0.0 |  0.04
Output  | 6.1236e-05 | 6.1236e-05 | 6.1236e-05 |   0.0 |  0.00
Modify  | 0.12334    | 0.12334    | 0.12334    |   0.0 |  0.17
Other   |            | 0.0117     |            |       |  0.02

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

Total # of neighbors = 558880
Ave neighs/atom = 139.72
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.870695698345, Press = 2.35776066911876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -22778.181     -22778.181     -22931.071     -22931.071      295.7754       295.7754       60592.192      60592.192      2039.0784      2039.0784    
     18000  -22775.196     -22775.196     -22926.23      -22926.23       292.18581      292.18581      60595.491      60595.491      2601.2266      2601.2266    
Loop time of 71.7323 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.926 hours/ns, 13.941 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    | 71.568     | 71.568     | 71.568     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029247   | 0.029247   | 0.029247   |   0.0 |  0.04
Output  | 6.0754e-05 | 6.0754e-05 | 6.0754e-05 |   0.0 |  0.00
Modify  | 0.12336    | 0.12336    | 0.12336    |   0.0 |  0.17
Other   |            | 0.01178    |            |       |  0.02

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

Total # of neighbors = 558894
Ave neighs/atom = 139.7235
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 = 292.981825849358, Press = -0.292768206047999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -22775.196     -22775.196     -22926.23      -22926.23       292.18581      292.18581      60595.491      60595.491      2601.2266      2601.2266    
     19000  -22776.346     -22776.346     -22927.552     -22927.552      292.51825      292.51825      60648.971      60648.971     -43.524905     -43.524905    
Loop time of 71.7317 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.925 hours/ns, 13.941 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    | 71.567     | 71.567     | 71.567     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029188   | 0.029188   | 0.029188   |   0.0 |  0.04
Output  | 6.2388e-05 | 6.2388e-05 | 6.2388e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.17
Other   |            | 0.01173    |            |       |  0.02

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

Total # of neighbors = 558814
Ave neighs/atom = 139.7035
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 = 292.962319595562, Press = 2.90388470339093
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -22776.346     -22776.346     -22927.552     -22927.552      292.51825      292.51825      60648.971      60648.971     -43.524905     -43.524905    
     20000  -22778.606     -22778.606     -22929.226     -22929.226      291.3845       291.3845       60630.654      60630.654      554.66833      554.66833    
Loop time of 71.6969 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.205 ns/day, 19.916 hours/ns, 13.948 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    | 71.533     | 71.533     | 71.533     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029217   | 0.029217   | 0.029217   |   0.0 |  0.04
Output  | 6.0615e-05 | 6.0615e-05 | 6.0615e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.17
Other   |            | 0.01174    |            |       |  0.02

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

Total # of neighbors = 558792
Ave neighs/atom = 139.698
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 = 292.913689984746, Press = 1.02726693199723
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -22778.606     -22778.606     -22929.226     -22929.226      291.3845       291.3845       60630.654      60630.654      554.66833      554.66833    
     21000  -22778.892     -22778.892     -22931.072     -22931.072      294.40185      294.40185      60638.783      60638.783     -236.23094     -236.23094    
Loop time of 71.9725 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.200 ns/day, 19.992 hours/ns, 13.894 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    | 71.808     | 71.808     | 71.808     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029491   | 0.029491   | 0.029491   |   0.0 |  0.04
Output  | 6.1336e-05 | 6.1336e-05 | 6.1336e-05 |   0.0 |  0.00
Modify  | 0.12341    | 0.12341    | 0.12341    |   0.0 |  0.17
Other   |            | 0.0117     |            |       |  0.02

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

Total # of neighbors = 558848
Ave neighs/atom = 139.712
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 = 292.927612334371, Press = 4.21984798130714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -22778.892     -22778.892     -22931.072     -22931.072      294.40185      294.40185      60638.783      60638.783     -236.23094     -236.23094    
     22000  -22774.544     -22774.544     -22925.509     -22925.509      292.05188      292.05188      60649.263      60649.263      101.8771       101.8771     
Loop time of 71.7735 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.937 hours/ns, 13.933 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    | 71.609     | 71.609     | 71.609     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029234   | 0.029234   | 0.029234   |   0.0 |  0.04
Output  | 6.0594e-05 | 6.0594e-05 | 6.0594e-05 |   0.0 |  0.00
Modify  | 0.1234     | 0.1234     | 0.1234     |   0.0 |  0.17
Other   |            | 0.01169    |            |       |  0.02

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

Total # of neighbors = 558756
Ave neighs/atom = 139.689
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.84098075615, Press = 3.14684405409174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -22774.544     -22774.544     -22925.509     -22925.509      292.05188      292.05188      60649.263      60649.263      101.8771       101.8771     
     23000  -22781.043     -22781.043     -22931.953     -22931.953      291.94555      291.94555      60658.4        60658.4       -1087.5155     -1087.5155    
Loop time of 71.8958 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.971 hours/ns, 13.909 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    | 71.731     | 71.731     | 71.731     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029255   | 0.029255   | 0.029255   |   0.0 |  0.04
Output  | 5.7539e-05 | 5.7539e-05 | 5.7539e-05 |   0.0 |  0.00
Modify  | 0.12352    | 0.12352    | 0.12352    |   0.0 |  0.17
Other   |            | 0.0118     |            |       |  0.02

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

Total # of neighbors = 558712
Ave neighs/atom = 139.678
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 = 292.842187620133, Press = 1.90695402048371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -22781.043     -22781.043     -22931.953     -22931.953      291.94555      291.94555      60658.4        60658.4       -1087.5155     -1087.5155    
     24000  -22781.256     -22781.256     -22929.061     -22929.061      285.93896      285.93896      60654.812      60654.812     -712.62223     -712.62223    
Loop time of 71.7871 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.941 hours/ns, 13.930 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    | 71.622     | 71.622     | 71.622     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029379   | 0.029379   | 0.029379   |   0.0 |  0.04
Output  | 6.1215e-05 | 6.1215e-05 | 6.1215e-05 |   0.0 |  0.00
Modify  | 0.12354    | 0.12354    | 0.12354    |   0.0 |  0.17
Other   |            | 0.01177    |            |       |  0.02

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

Total # of neighbors = 558846
Ave neighs/atom = 139.7115
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 = 292.849484652369, Press = 0.179842586955908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -22781.256     -22781.256     -22929.061     -22929.061      285.93896      285.93896      60654.812      60654.812     -712.62223     -712.62223    
     25000  -22777.969     -22777.969     -22928.77      -22928.77       291.73548      291.73548      60609.254      60609.254      1618.8669      1618.8669    
Loop time of 71.8421 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.956 hours/ns, 13.919 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    | 71.677     | 71.677     | 71.677     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029261   | 0.029261   | 0.029261   |   0.0 |  0.04
Output  | 6.0093e-05 | 6.0093e-05 | 6.0093e-05 |   0.0 |  0.00
Modify  | 0.12359    | 0.12359    | 0.12359    |   0.0 |  0.17
Other   |            | 0.01176    |            |       |  0.02

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

Total # of neighbors = 558724
Ave neighs/atom = 139.681
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 = 292.808458370613, Press = 1.76655999629756
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -22777.969     -22777.969     -22928.77      -22928.77       291.73548      291.73548      60609.254      60609.254      1618.8669      1618.8669    
     26000  -22782.46      -22782.46      -22933.313     -22933.313      291.83462      291.83462      60633.639      60633.639     -178.74509     -178.74509    
Loop time of 71.9757 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.200 ns/day, 19.993 hours/ns, 13.894 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    | 71.811     | 71.811     | 71.811     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029314   | 0.029314   | 0.029314   |   0.0 |  0.04
Output  | 6.1045e-05 | 6.1045e-05 | 6.1045e-05 |   0.0 |  0.00
Modify  | 0.12358    | 0.12358    | 0.12358    |   0.0 |  0.17
Other   |            | 0.01178    |            |       |  0.02

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

Total # of neighbors = 558862
Ave neighs/atom = 139.7155
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 = 292.786338888682, Press = -0.339687369062689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -22782.46      -22782.46      -22933.313     -22933.313      291.83462      291.83462      60633.639      60633.639     -178.74509     -178.74509    
     27000  -22775.432     -22775.432     -22927.298     -22927.298      293.79683      293.79683      60614.774      60614.774      1574.52        1574.52      
Loop time of 71.8331 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.954 hours/ns, 13.921 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    | 71.668     | 71.668     | 71.668     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029337   | 0.029337   | 0.029337   |   0.0 |  0.04
Output  | 6.5343e-05 | 6.5343e-05 | 6.5343e-05 |   0.0 |  0.00
Modify  | 0.12348    | 0.12348    | 0.12348    |   0.0 |  0.17
Other   |            | 0.01176    |            |       |  0.02

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

Total # of neighbors = 558880
Ave neighs/atom = 139.72
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743067709084, Press = -0.232242236102633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -22775.432     -22775.432     -22927.298     -22927.298      293.79683      293.79683      60614.774      60614.774      1574.52        1574.52      
     28000  -22783.54      -22783.54      -22930.485     -22930.485      284.27534      284.27534      60628.985      60628.985      311.89712      311.89712    
Loop time of 71.84 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.956 hours/ns, 13.920 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    | 71.675     | 71.675     | 71.675     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02928    | 0.02928    | 0.02928    |   0.0 |  0.04
Output  | 5.7578e-05 | 5.7578e-05 | 5.7578e-05 |   0.0 |  0.00
Modify  | 0.12357    | 0.12357    | 0.12357    |   0.0 |  0.17
Other   |            | 0.01178    |            |       |  0.02

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

Total # of neighbors = 558798
Ave neighs/atom = 139.6995
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 = 292.713554637712, Press = 0.600412780215522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -22783.54      -22783.54      -22930.485     -22930.485      284.27534      284.27534      60628.985      60628.985      311.89712      311.89712    
     29000  -22776.156     -22776.156     -22929.725     -22929.725      297.08957      297.08957      60654.117      60654.117     -566.69898     -566.69898    
Loop time of 71.8615 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.962 hours/ns, 13.916 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    | 71.697     | 71.697     | 71.697     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029287   | 0.029287   | 0.029287   |   0.0 |  0.04
Output  | 5.9792e-05 | 5.9792e-05 | 5.9792e-05 |   0.0 |  0.00
Modify  | 0.12344    | 0.12344    | 0.12344    |   0.0 |  0.17
Other   |            | 0.01178    |            |       |  0.02

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

Total # of neighbors = 558924
Ave neighs/atom = 139.731
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 = 292.652161686602, Press = -0.503738258631964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -22776.156     -22776.156     -22929.725     -22929.725      297.08957      297.08957      60654.117      60654.117     -566.69898     -566.69898    
     30000  -22776.358     -22776.358     -22928.029     -22928.029      293.41817      293.41817      60649.314      60649.314     -218.99477     -218.99477    
Loop time of 71.858 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.961 hours/ns, 13.916 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    | 71.693     | 71.693     | 71.693     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029217   | 0.029217   | 0.029217   |   0.0 |  0.04
Output  | 7.1024e-05 | 7.1024e-05 | 7.1024e-05 |   0.0 |  0.00
Modify  | 0.12358    | 0.12358    | 0.12358    |   0.0 |  0.17
Other   |            | 0.01175    |            |       |  0.02

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

Total # of neighbors = 558808
Ave neighs/atom = 139.702
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.63900784258, Press = 0.352165181892517
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -22776.358     -22776.358     -22928.029     -22928.029      293.41817      293.41817      60649.314      60649.314     -218.99477     -218.99477    
     31000  -22779.523     -22779.523     -22931.258     -22931.258      293.54244      293.54244      60623.895      60623.895      466.60616      466.60616    
Loop time of 71.8063 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.946 hours/ns, 13.926 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    | 71.642     | 71.642     | 71.642     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029205   | 0.029205   | 0.029205   |   0.0 |  0.04
Output  | 5.9422e-05 | 5.9422e-05 | 5.9422e-05 |   0.0 |  0.00
Modify  | 0.12348    | 0.12348    | 0.12348    |   0.0 |  0.17
Other   |            | 0.01179    |            |       |  0.02

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

Total # of neighbors = 558846
Ave neighs/atom = 139.7115
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 = 292.646961209933, Press = 0.208962357411697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -22779.523     -22779.523     -22931.258     -22931.258      293.54244      293.54244      60623.895      60623.895      466.60616      466.60616    
     32000  -22776.94      -22776.94      -22929.325     -22929.325      294.79891      294.79891      60595.301      60595.301      2159.3105      2159.3105    
Loop time of 71.9644 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.990 hours/ns, 13.896 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    | 71.8       | 71.8       | 71.8       |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029308   | 0.029308   | 0.029308   |   0.0 |  0.04
Output  | 6.0333e-05 | 6.0333e-05 | 6.0333e-05 |   0.0 |  0.00
Modify  | 0.12344    | 0.12344    | 0.12344    |   0.0 |  0.17
Other   |            | 0.01182    |            |       |  0.02

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

Total # of neighbors = 558916
Ave neighs/atom = 139.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 = 292.683951039128, Press = 0.900097683612731
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -22776.94      -22776.94      -22929.325     -22929.325      294.79891      294.79891      60595.301      60595.301      2159.3105      2159.3105    
     33000  -22774.624     -22774.624     -22927.736     -22927.736      296.20527      296.20527      60614.321      60614.321      1547.5502      1547.5502    
Loop time of 71.8493 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.958 hours/ns, 13.918 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    | 71.684     | 71.684     | 71.684     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029571   | 0.029571   | 0.029571   |   0.0 |  0.04
Output  | 5.9543e-05 | 5.9543e-05 | 5.9543e-05 |   0.0 |  0.00
Modify  | 0.12346    | 0.12346    | 0.12346    |   0.0 |  0.17
Other   |            | 0.01182    |            |       |  0.02

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

Total # of neighbors = 558890
Ave neighs/atom = 139.7225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.72246377405, Press = 0.0554457560833768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -22774.624     -22774.624     -22927.736     -22927.736      296.20527      296.20527      60614.321      60614.321      1547.5502      1547.5502    
     34000  -22778.094     -22778.094     -22927.443     -22927.443      288.92634      288.92634      60662.938      60662.938     -730.10895     -730.10895    
Loop time of 72.075 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.199 ns/day, 20.021 hours/ns, 13.874 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    | 71.911     | 71.911     | 71.911     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029288   | 0.029288   | 0.029288   |   0.0 |  0.04
Output  | 6.0604e-05 | 6.0604e-05 | 6.0604e-05 |   0.0 |  0.00
Modify  | 0.12335    | 0.12335    | 0.12335    |   0.0 |  0.17
Other   |            | 0.01178    |            |       |  0.02

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

Total # of neighbors = 558764
Ave neighs/atom = 139.691
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 = 292.800357883231, Press = -0.0276309515140687
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -22778.094     -22778.094     -22927.443     -22927.443      288.92634      288.92634      60662.938      60662.938     -730.10895     -730.10895    
     35000  -22784.262     -22784.262     -22930.284     -22930.284      282.48865      282.48865      60683.35       60683.35      -2106.3968     -2106.3968    
Loop time of 71.7909 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.942 hours/ns, 13.929 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    | 71.626     | 71.626     | 71.626     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029207   | 0.029207   | 0.029207   |   0.0 |  0.04
Output  | 5.9431e-05 | 5.9431e-05 | 5.9431e-05 |   0.0 |  0.00
Modify  | 0.1235     | 0.1235     | 0.1235     |   0.0 |  0.17
Other   |            | 0.01178    |            |       |  0.02

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

Total # of neighbors = 558834
Ave neighs/atom = 139.7085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.75821676557, Press = 0.513904235403839
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -22784.262     -22784.262     -22930.284     -22930.284      282.48865      282.48865      60683.35       60683.35      -2106.3968     -2106.3968    
     36000  -22776.904     -22776.904     -22930.094     -22930.094      296.35505      296.35505      60653.301      60653.301     -577.46268     -577.46268    
Loop time of 71.9024 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.973 hours/ns, 13.908 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    | 71.738     | 71.738     | 71.738     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029168   | 0.029168   | 0.029168   |   0.0 |  0.04
Output  | 5.814e-05  | 5.814e-05  | 5.814e-05  |   0.0 |  0.00
Modify  | 0.12347    | 0.12347    | 0.12347    |   0.0 |  0.17
Other   |            | 0.01175    |            |       |  0.02

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

Total # of neighbors = 558826
Ave neighs/atom = 139.7065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.76399551863, Press = 1.2031789168691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -22776.904     -22776.904     -22930.094     -22930.094      296.35505      296.35505      60653.301      60653.301     -577.46268     -577.46268    
     37000  -22777.366     -22777.366     -22928.577     -22928.577      292.52844      292.52844      60659.665      60659.665     -663.96617     -663.96617    
Loop time of 71.9455 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.985 hours/ns, 13.899 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    | 71.781     | 71.781     | 71.781     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029443   | 0.029443   | 0.029443   |   0.0 |  0.04
Output  | 6.1586e-05 | 6.1586e-05 | 6.1586e-05 |   0.0 |  0.00
Modify  | 0.12346    | 0.12346    | 0.12346    |   0.0 |  0.17
Other   |            | 0.01182    |            |       |  0.02

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

Total # of neighbors = 558772
Ave neighs/atom = 139.693
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 = 292.761624821184, Press = 0.768221483880871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -22777.366     -22777.366     -22928.577     -22928.577      292.52844      292.52844      60659.665      60659.665     -663.96617     -663.96617    
     38000  -22780.171     -22780.171     -22930.668     -22930.668      291.14663      291.14663      60640.094      60640.094     -125.74954     -125.74954    
Loop time of 71.9266 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.980 hours/ns, 13.903 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    | 71.762     | 71.762     | 71.762     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029191   | 0.029191   | 0.029191   |   0.0 |  0.04
Output  | 5.6377e-05 | 5.6377e-05 | 5.6377e-05 |   0.0 |  0.00
Modify  | 0.12348    | 0.12348    | 0.12348    |   0.0 |  0.17
Other   |            | 0.01175    |            |       |  0.02

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

Total # of neighbors = 558732
Ave neighs/atom = 139.683
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 = 292.803710183527, Press = 1.05177144871455
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -22780.171     -22780.171     -22930.668     -22930.668      291.14663      291.14663      60640.094      60640.094     -125.74954     -125.74954    
     39000  -22774.58      -22774.58      -22926.845     -22926.845      294.56694      294.56694      60606.788      60606.788      2010.7006      2010.7006    
Loop time of 71.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.936 hours/ns, 13.933 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    | 71.606     | 71.606     | 71.606     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029307   | 0.029307   | 0.029307   |   0.0 |  0.04
Output  | 5.9902e-05 | 5.9902e-05 | 5.9902e-05 |   0.0 |  0.00
Modify  | 0.12363    | 0.12363    | 0.12363    |   0.0 |  0.17
Other   |            | 0.01177    |            |       |  0.02

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

Total # of neighbors = 558778
Ave neighs/atom = 139.6945
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 = 292.817051679821, Press = 0.627204839492013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -22774.58      -22774.58      -22926.845     -22926.845      294.56694      294.56694      60606.788      60606.788      2010.7006      2010.7006    
     40000  -22780.437     -22780.437     -22931.63      -22931.63       292.49432      292.49432      60583.457      60583.457      2453.1373      2453.1373    
Loop time of 72.0961 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.198 ns/day, 20.027 hours/ns, 13.870 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    | 71.931     | 71.931     | 71.931     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029321   | 0.029321   | 0.029321   |   0.0 |  0.04
Output  | 7.8218e-05 | 7.8218e-05 | 7.8218e-05 |   0.0 |  0.00
Modify  | 0.12372    | 0.12372    | 0.12372    |   0.0 |  0.17
Other   |            | 0.01182    |            |       |  0.02

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

Total # of neighbors = 558828
Ave neighs/atom = 139.707
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 = 292.874552402052, Press = 0.687601569955836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -22780.437     -22780.437     -22931.63      -22931.63       292.49432      292.49432      60583.457      60583.457      2453.1373      2453.1373    
     41000  -22775.283     -22775.283     -22927.566     -22927.566      294.60072      294.60072      60647.083      60647.083      94.441275      94.441275    
Loop time of 71.8667 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.963 hours/ns, 13.915 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    | 71.702     | 71.702     | 71.702     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029371   | 0.029371   | 0.029371   |   0.0 |  0.04
Output  | 6.924e-05  | 6.924e-05  | 6.924e-05  |   0.0 |  0.00
Modify  | 0.12358    | 0.12358    | 0.12358    |   0.0 |  0.17
Other   |            | 0.01176    |            |       |  0.02

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

Total # of neighbors = 558950
Ave neighs/atom = 139.7375
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 = 292.850201628125, Press = 0.542902486759547
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -22775.283     -22775.283     -22927.566     -22927.566      294.60072      294.60072      60647.083      60647.083      94.441275      94.441275    
     42000  -22778.945     -22778.945     -22929.746     -22929.746      291.7358       291.7358       60623.42       60623.42       721.82987      721.82987    
Loop time of 71.9228 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.979 hours/ns, 13.904 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 71.758     | 71.758     | 71.758     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029334   | 0.029334   | 0.029334   |   0.0 |  0.04
Output  | 7.6204e-05 | 7.6204e-05 | 7.6204e-05 |   0.0 |  0.00
Modify  | 0.12352    | 0.12352    | 0.12352    |   0.0 |  0.17
Other   |            | 0.01176    |            |       |  0.02

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

Total # of neighbors = 558838
Ave neighs/atom = 139.7095
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 = 292.817304753897, Press = 1.00260767096457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -22778.945     -22778.945     -22929.746     -22929.746      291.7358       291.7358       60623.42       60623.42       721.82987      721.82987    
     43000  -22771.612     -22771.612     -22925.199     -22925.199      297.12598      297.12598      60675.638      60675.638     -1063.9875     -1063.9875    
Loop time of 71.9877 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.200 ns/day, 19.997 hours/ns, 13.891 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    | 71.823     | 71.823     | 71.823     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029534   | 0.029534   | 0.029534   |   0.0 |  0.04
Output  | 5.5214e-05 | 5.5214e-05 | 5.5214e-05 |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.17
Other   |            | 0.01173    |            |       |  0.02

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

Total # of neighbors = 558786
Ave neighs/atom = 139.6965
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 = 292.85281375868, Press = 2.27183393527761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -22771.612     -22771.612     -22925.199     -22925.199      297.12598      297.12598      60675.638      60675.638     -1063.9875     -1063.9875    
     44000  -22779.702     -22779.702     -22930.533     -22930.533      291.7943       291.7943       60641.161      60641.161     -247.65531     -247.65531    
Loop time of 72.0916 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.198 ns/day, 20.025 hours/ns, 13.871 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    | 71.927     | 71.927     | 71.927     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029219   | 0.029219   | 0.029219   |   0.0 |  0.04
Output  | 6.4852e-05 | 6.4852e-05 | 6.4852e-05 |   0.0 |  0.00
Modify  | 0.12353    | 0.12353    | 0.12353    |   0.0 |  0.17
Other   |            | 0.0118     |            |       |  0.02

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

Total # of neighbors = 558710
Ave neighs/atom = 139.6775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.88670637543, Press = 1.3426068308925
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -22779.702     -22779.702     -22930.533     -22930.533      291.7943       291.7943       60641.161      60641.161     -247.65531     -247.65531    
     45000  -22777.501     -22777.501     -22928.01      -22928.01       291.16909      291.16909      60674.481      60674.481     -1423.4559     -1423.4559    
Loop time of 72.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.200 ns/day, 20.001 hours/ns, 13.888 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    | 71.841     | 71.841     | 71.841     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029322   | 0.029322   | 0.029322   |   0.0 |  0.04
Output  | 6.9821e-05 | 6.9821e-05 | 6.9821e-05 |   0.0 |  0.00
Modify  | 0.12315    | 0.12315    | 0.12315    |   0.0 |  0.17
Other   |            | 0.01174    |            |       |  0.02

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

Total # of neighbors = 558758
Ave neighs/atom = 139.6895
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 = 292.871096346434, Press = 1.02803976051563
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -22777.501     -22777.501     -22928.01      -22928.01       291.16909      291.16909      60674.481      60674.481     -1423.4559     -1423.4559    
     46000  -22774.901     -22774.901     -22927.724     -22927.724      295.64758      295.64758      60585.336      60585.336      2951.3255      2951.3255    
Loop time of 71.9771 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.200 ns/day, 19.994 hours/ns, 13.893 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    | 71.813     | 71.813     | 71.813     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029444   | 0.029444   | 0.029444   |   0.0 |  0.04
Output  | 7.2267e-05 | 7.2267e-05 | 7.2267e-05 |   0.0 |  0.00
Modify  | 0.12338    | 0.12338    | 0.12338    |   0.0 |  0.17
Other   |            | 0.01173    |            |       |  0.02

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

Total # of neighbors = 558684
Ave neighs/atom = 139.671
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 = 292.843340366802, Press = 0.773874742501598
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -22774.901     -22774.901     -22927.724     -22927.724      295.64758      295.64758      60585.336      60585.336      2951.3255      2951.3255    
     47000  -22778.995     -22778.995     -22931.524     -22931.524      295.07772      295.07772      60575.159      60575.159      2795.0227      2795.0227    
Loop time of 71.9123 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.976 hours/ns, 13.906 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    | 71.748     | 71.748     | 71.748     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029275   | 0.029275   | 0.029275   |   0.0 |  0.04
Output  | 6.7717e-05 | 6.7717e-05 | 6.7717e-05 |   0.0 |  0.00
Modify  | 0.12357    | 0.12357    | 0.12357    |   0.0 |  0.17
Other   |            | 0.01182    |            |       |  0.02

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

Total # of neighbors = 558880
Ave neighs/atom = 139.72
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.859486418103, Press = 0.464737246518722
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -22778.995     -22778.995     -22931.524     -22931.524      295.07772      295.07772      60575.159      60575.159      2795.0227      2795.0227    
     48000  -22773.267     -22773.267     -22926.258     -22926.258      295.97167      295.97167      60662.67       60662.67      -592.94299     -592.94299    
Loop time of 71.9235 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.979 hours/ns, 13.904 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 71.758     | 71.758     | 71.758     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029392   | 0.029392   | 0.029392   |   0.0 |  0.04
Output  | 6.5443e-05 | 6.5443e-05 | 6.5443e-05 |   0.0 |  0.00
Modify  | 0.12385    | 0.12385    | 0.12385    |   0.0 |  0.17
Other   |            | 0.01181    |            |       |  0.02

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

Total # of neighbors = 558922
Ave neighs/atom = 139.7305
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 = 292.908459339551, Press = 0.524567743543016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -22773.267     -22773.267     -22926.258     -22926.258      295.97167      295.97167      60662.67       60662.67      -592.94299     -592.94299    
     49000  -22777.262     -22777.262     -22928.196     -22928.196      291.99142      291.99142      60702.46       60702.46      -2677.3732     -2677.3732    
Loop time of 71.8865 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.968 hours/ns, 13.911 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    | 71.722     | 71.722     | 71.722     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029284   | 0.029284   | 0.029284   |   0.0 |  0.04
Output  | 6.7517e-05 | 6.7517e-05 | 6.7517e-05 |   0.0 |  0.00
Modify  | 0.12381    | 0.12381    | 0.12381    |   0.0 |  0.17
Other   |            | 0.01179    |            |       |  0.02

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

Total # of neighbors = 558802
Ave neighs/atom = 139.7005
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 = 292.936891147399, Press = -0.317812574573228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -22777.262     -22777.262     -22928.196     -22928.196      291.99142      291.99142      60702.46       60702.46      -2677.3732     -2677.3732    
     50000  -22777.569     -22777.569     -22928.516     -22928.516      292.01725      292.01725      60691.249      60691.249     -2138.3589     -2138.3589    
Loop time of 71.8765 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.966 hours/ns, 13.913 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    | 71.711     | 71.711     | 71.711     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029512   | 0.029512   | 0.029512   |   0.0 |  0.04
Output  | 6.7197e-05 | 6.7197e-05 | 6.7197e-05 |   0.0 |  0.00
Modify  | 0.12375    | 0.12375    | 0.12375    |   0.0 |  0.17
Other   |            | 0.01181    |            |       |  0.02

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

Total # of neighbors = 558778
Ave neighs/atom = 139.6945
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 = 292.953230785336, Press = 0.849345369660904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -22777.569     -22777.569     -22928.516     -22928.516      292.01725      292.01725      60691.249      60691.249     -2138.3589     -2138.3589    
     51000  -22775.648     -22775.648     -22928.961     -22928.961      296.59529      296.59529      60652.401      60652.401     -438.83209     -438.83209    
Loop time of 71.8662 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.963 hours/ns, 13.915 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    | 71.701     | 71.701     | 71.701     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0293     | 0.0293     | 0.0293     |   0.0 |  0.04
Output  | 7.3448e-05 | 7.3448e-05 | 7.3448e-05 |   0.0 |  0.00
Modify  | 0.12379    | 0.12379    | 0.12379    |   0.0 |  0.17
Other   |            | 0.01186    |            |       |  0.02

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

Total # of neighbors = 558708
Ave neighs/atom = 139.677
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 = 292.946933718765, Press = 0.44851434052786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -22775.648     -22775.648     -22928.961     -22928.961      296.59529      296.59529      60652.401      60652.401     -438.83209     -438.83209    
     52000  -22782.702     -22782.702     -22930.46      -22930.46       285.84793      285.84793      60625.161      60625.161      551.97006      551.97006    
Loop time of 72.0529 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.199 ns/day, 20.015 hours/ns, 13.879 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    | 71.888     | 71.888     | 71.888     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029435   | 0.029435   | 0.029435   |   0.0 |  0.04
Output  | 6.7727e-05 | 6.7727e-05 | 6.7727e-05 |   0.0 |  0.00
Modify  | 0.12356    | 0.12356    | 0.12356    |   0.0 |  0.17
Other   |            | 0.01181    |            |       |  0.02

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

Total # of neighbors = 558812
Ave neighs/atom = 139.703
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.941321311433, Press = 0.838761880540433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -22782.702     -22782.702     -22930.46      -22930.46       285.84793      285.84793      60625.161      60625.161      551.97006      551.97006    
     53000  -22776.278     -22776.278     -22927.044     -22927.044      291.66739      291.66739      60616.457      60616.457      1434.3893      1434.3893    
Loop time of 71.9017 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.973 hours/ns, 13.908 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    | 71.737     | 71.737     | 71.737     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029267   | 0.029267   | 0.029267   |   0.0 |  0.04
Output  | 6.9821e-05 | 6.9821e-05 | 6.9821e-05 |   0.0 |  0.00
Modify  | 0.12351    | 0.12351    | 0.12351    |   0.0 |  0.17
Other   |            | 0.01184    |            |       |  0.02

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

Total # of neighbors = 558900
Ave neighs/atom = 139.725
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 = 292.916377934253, Press = 0.639571155718465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -22776.278     -22776.278     -22927.044     -22927.044      291.66739      291.66739      60616.457      60616.457      1434.3893      1434.3893    
     54000  -22782.159     -22782.159     -22932.192     -22932.192      290.24816      290.24816      60651.434      60651.434     -992.1322      -992.1322     
Loop time of 71.9675 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.991 hours/ns, 13.895 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    | 71.802     | 71.802     | 71.802     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029384   | 0.029384   | 0.029384   |   0.0 |  0.04
Output  | 6.88e-05   | 6.88e-05   | 6.88e-05   |   0.0 |  0.00
Modify  | 0.12381    | 0.12381    | 0.12381    |   0.0 |  0.17
Other   |            | 0.01184    |            |       |  0.02

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

Total # of neighbors = 558792
Ave neighs/atom = 139.698
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 = 292.895767230001, Press = 0.179964481438253
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -22782.159     -22782.159     -22932.192     -22932.192      290.24816      290.24816      60651.434      60651.434     -992.1322      -992.1322     
     55000  -22780.147     -22780.147     -22930.097     -22930.097      290.08998      290.08998      60616.271      60616.271      1016.522       1016.522     
Loop time of 72.0759 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.199 ns/day, 20.021 hours/ns, 13.874 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    | 71.911     | 71.911     | 71.911     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029401   | 0.029401   | 0.029401   |   0.0 |  0.04
Output  | 7.1084e-05 | 7.1084e-05 | 7.1084e-05 |   0.0 |  0.00
Modify  | 0.12355    | 0.12355    | 0.12355    |   0.0 |  0.17
Other   |            | 0.01181    |            |       |  0.02

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

Total # of neighbors = 558850
Ave neighs/atom = 139.7125
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 = 292.909179835862, Press = 1.14740816464704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -22780.147     -22780.147     -22930.097     -22930.097      290.08998      290.08998      60616.271      60616.271      1016.522       1016.522     
     56000  -22773.871     -22773.871     -22925.508     -22925.508      293.35163      293.35163      60629.828      60629.828      1087.4934      1087.4934    
Loop time of 71.8885 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.202 ns/day, 19.969 hours/ns, 13.910 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    | 71.724     | 71.724     | 71.724     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02943    | 0.02943    | 0.02943    |   0.0 |  0.04
Output  | 7.3949e-05 | 7.3949e-05 | 7.3949e-05 |   0.0 |  0.00
Modify  | 0.12348    | 0.12348    | 0.12348    |   0.0 |  0.17
Other   |            | 0.01182    |            |       |  0.02

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

Total # of neighbors = 558864
Ave neighs/atom = 139.716
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 = 292.924557387285, Press = 1.57732923990035
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -22773.871     -22773.871     -22925.508     -22925.508      293.35163      293.35163      60629.828      60629.828      1087.4934      1087.4934    
     57000  -22779.64      -22779.64      -22930.493     -22930.493      291.83603      291.83603      60632.34       60632.34       261.87858      261.87858    
Loop time of 71.9365 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.201 ns/day, 19.982 hours/ns, 13.901 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    | 71.772     | 71.772     | 71.772     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029341   | 0.029341   | 0.029341   |   0.0 |  0.04
Output  | 7.4831e-05 | 7.4831e-05 | 7.4831e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.17
Other   |            | 0.01182    |            |       |  0.02

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

Total # of neighbors = 558820
Ave neighs/atom = 139.705
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
60641.6357501866

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0