# 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 5.431141197681427*${_u_distance}
variable latticeconst_converted equal 5.431141197681427*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.43114119768143
Lattice spacing in x,y,z = 5.4311412 5.4311412 5.4311412
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (54.311412 54.311412 54.311412)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0 0 0) to (54.311412 54.311412 54.311412)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Si

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

kim interactions Si
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_DuLenoskyHennig_2011_Si__MO_883726743759_002
pair_coeff * * Si
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 28.0855

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 16 16 16
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.657 | 8.657 | 8.657 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -36783.314     -36783.314     -37045.059     -37045.059      253.15         253.15         160203.97      160203.97      1745.1279      1745.1279    
      1000  -36489.849     -36489.849     -36763.384     -36763.384      264.5533       264.5533       159634.39      159634.39     -548.86642     -548.86642    
Loop time of 573.39 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 159.275 hours/ns, 1.744 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 571.55     | 571.55     | 571.55     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.26048    | 0.26048    | 0.26048    |   0.0 |  0.05
Output  | 0.00028483 | 0.00028483 | 0.00028483 |   0.0 |  0.00
Modify  | 1.4045     | 1.4045     | 1.4045     |   0.0 |  0.24
Other   |            | 0.1713     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       688000 ave      688000 max      688000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 688000
Ave neighs/atom = 86
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -36489.849     -36489.849     -36763.384     -36763.384      264.5533       264.5533       159634.39      159634.39     -548.86642     -548.86642    
      2000  -36520.983     -36520.983     -36775.463     -36775.463      246.12412      246.12412      159525.34      159525.34     -18.192881     -18.192881    
Loop time of 587.229 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.119 hours/ns, 1.703 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.34     | 585.34     | 585.34     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25747    | 0.25747    | 0.25747    |   0.0 |  0.04
Output  | 0.00039601 | 0.00039601 | 0.00039601 |   0.0 |  0.00
Modify  | 1.4557     | 1.4557     | 1.4557     |   0.0 |  0.25
Other   |            | 0.1756     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685856 ave      685856 max      685856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685856
Ave neighs/atom = 85.732
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -36520.983     -36520.983     -36775.463     -36775.463      246.12412      246.12412      159525.34      159525.34     -18.192881     -18.192881    
      3000  -36503.398     -36503.398     -36773.521     -36773.521      261.25255      261.25255      159625.51      159625.51     -654.09479     -654.09479    
Loop time of 585.895 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 162.749 hours/ns, 1.707 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 584        | 584        | 584        |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25895    | 0.25895    | 0.25895    |   0.0 |  0.04
Output  | 0.00031388 | 0.00031388 | 0.00031388 |   0.0 |  0.00
Modify  | 1.4575     | 1.4575     | 1.4575     |   0.0 |  0.25
Other   |            | 0.1752     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686356 ave      686356 max      686356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686356
Ave neighs/atom = 85.7945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -36503.398     -36503.398     -36773.521     -36773.521      261.25255      261.25255      159625.51      159625.51     -654.09479     -654.09479    
      4000  -36513.479     -36513.479     -36779.276     -36779.276      257.06917      257.06917      159539.9       159539.9       168.20548      168.20548    
Loop time of 585.152 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 162.542 hours/ns, 1.709 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 583.29     | 583.29     | 583.29     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25454    | 0.25454    | 0.25454    |   0.0 |  0.04
Output  | 0.00027846 | 0.00027846 | 0.00027846 |   0.0 |  0.00
Modify  | 1.4337     | 1.4337     | 1.4337     |   0.0 |  0.25
Other   |            | 0.174      |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685940 ave      685940 max      685940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685940
Ave neighs/atom = 85.7425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -36513.479     -36513.479     -36779.276     -36779.276      257.06917      257.06917      159539.9       159539.9       168.20548      168.20548    
      5000  -36507.959     -36507.959     -36770.661     -36770.661      254.07567      254.07567      159700.31      159700.31     -883.81437     -883.81437    
Loop time of 579.729 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.036 hours/ns, 1.725 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 577.87     | 577.87     | 577.87     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25478    | 0.25478    | 0.25478    |   0.0 |  0.04
Output  | 0.0002391  | 0.0002391  | 0.0002391  |   0.0 |  0.00
Modify  | 1.4272     | 1.4272     | 1.4272     |   0.0 |  0.25
Other   |            | 0.1729     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686366 ave      686366 max      686366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686366
Ave neighs/atom = 85.79575
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 = 255.198135493846, Press = 410.028020373549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -36507.959     -36507.959     -36770.661     -36770.661      254.07567      254.07567      159700.31      159700.31     -883.81437     -883.81437    
      6000  -36510.547     -36510.547     -36774.779     -36774.779      255.55573      255.55573      159512.23      159512.23      293.8736       293.8736     
Loop time of 584.224 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 162.284 hours/ns, 1.712 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 582.31     | 582.31     | 582.31     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25598    | 0.25598    | 0.25598    |   0.0 |  0.04
Output  | 0.0002399  | 0.0002399  | 0.0002399  |   0.0 |  0.00
Modify  | 1.4837     | 1.4837     | 1.4837     |   0.0 |  0.25
Other   |            | 0.1752     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686018 ave      686018 max      686018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686018
Ave neighs/atom = 85.75225
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 = 252.929735152257, Press = 19.7734812303793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -36510.547     -36510.547     -36774.779     -36774.779      255.55573      255.55573      159512.23      159512.23      293.8736       293.8736     
      7000  -36509.23      -36509.23      -36771.93      -36771.93       254.07351      254.07351      159695.07      159695.07     -864.27234     -864.27234    
Loop time of 583.751 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 581.85     | 581.85     | 581.85     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25531    | 0.25531    | 0.25531    |   0.0 |  0.04
Output  | 0.00024049 | 0.00024049 | 0.00024049 |   0.0 |  0.00
Modify  | 1.4735     | 1.4735     | 1.4735     |   0.0 |  0.25
Other   |            | 0.1727     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686266 ave      686266 max      686266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686266
Ave neighs/atom = 85.78325
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 = 253.191060845941, Press = 10.0049503415559
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -36509.23      -36509.23      -36771.93      -36771.93       254.07351      254.07351      159695.07      159695.07     -864.27234     -864.27234    
      8000  -36509.848     -36509.848     -36770.766     -36770.766      252.35018      252.35018      159529.9       159529.9      -203.32857     -203.32857    
Loop time of 577.44 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 575.57     | 575.57     | 575.57     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25277    | 0.25277    | 0.25277    |   0.0 |  0.04
Output  | 0.00024357 | 0.00024357 | 0.00024357 |   0.0 |  0.00
Modify  | 1.4472     | 1.4472     | 1.4472     |   0.0 |  0.25
Other   |            | 0.1706     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686116 ave      686116 max      686116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686116
Ave neighs/atom = 85.7645
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 = 253.069534947828, Press = 3.51683825717677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -36509.848     -36509.848     -36770.766     -36770.766      252.35018      252.35018      159529.9       159529.9      -203.32857     -203.32857    
      9000  -36511.653     -36511.653     -36772.759     -36772.759      252.53206      252.53206      159677.47      159677.47     -851.45063     -851.45063    
Loop time of 579.976 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.105 hours/ns, 1.724 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 578.09     | 578.09     | 578.09     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25469    | 0.25469    | 0.25469    |   0.0 |  0.04
Output  | 0.0002427  | 0.0002427  | 0.0002427  |   0.0 |  0.00
Modify  | 1.4577     | 1.4577     | 1.4577     |   0.0 |  0.25
Other   |            | 0.1729     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685920 ave      685920 max      685920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685920
Ave neighs/atom = 85.74
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 = 253.188826743479, Press = 5.82228051490158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -36511.653     -36511.653     -36772.759     -36772.759      252.53206      252.53206      159677.47      159677.47     -851.45063     -851.45063    
     10000  -36506.764     -36506.764     -36770.817     -36770.817      255.38204      255.38204      159517.32      159517.32      67.99479       67.99479     
Loop time of 580.532 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.259 hours/ns, 1.723 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 578.63     | 578.63     | 578.63     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25375    | 0.25375    | 0.25375    |   0.0 |  0.04
Output  | 0.00024394 | 0.00024394 | 0.00024394 |   0.0 |  0.00
Modify  | 1.4776     | 1.4776     | 1.4776     |   0.0 |  0.25
Other   |            | 0.1749     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685970 ave      685970 max      685970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685970
Ave neighs/atom = 85.74625
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 = 253.126970460143, Press = 3.85089321766574
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -36506.764     -36506.764     -36770.817     -36770.817      255.38204      255.38204      159517.32      159517.32      67.99479       67.99479     
     11000  -36511.064     -36511.064     -36769.378     -36769.378      249.83196      249.83196      159451.96      159451.96      183.10731      183.10731    
Loop time of 577.699 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 575.82     | 575.82     | 575.82     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25362    | 0.25362    | 0.25362    |   0.0 |  0.04
Output  | 0.00024023 | 0.00024023 | 0.00024023 |   0.0 |  0.00
Modify  | 1.4527     | 1.4527     | 1.4527     |   0.0 |  0.25
Other   |            | 0.1716     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686032 ave      686032 max      686032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686032
Ave neighs/atom = 85.754
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.205147162514, Press = 2.43344122741792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -36511.064     -36511.064     -36769.378     -36769.378      249.83196      249.83196      159451.96      159451.96      183.10731      183.10731    
     12000  -36506.813     -36506.813     -36770.857     -36770.857      255.37423      255.37423      159456.67      159456.67      121.01081      121.01081    
Loop time of 582.717 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 580.82     | 580.82     | 580.82     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25533    | 0.25533    | 0.25533    |   0.0 |  0.04
Output  | 0.00028857 | 0.00028857 | 0.00028857 |   0.0 |  0.00
Modify  | 1.4675     | 1.4675     | 1.4675     |   0.0 |  0.25
Other   |            | 0.172      |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686042 ave      686042 max      686042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686042
Ave neighs/atom = 85.75525
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 = 253.382516480097, Press = 1.10588149157205
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -36506.813     -36506.813     -36770.857     -36770.857      255.37423      255.37423      159456.67      159456.67      121.01081      121.01081    
     13000  -36505.689     -36505.689     -36771.053     -36771.053      256.65057      256.65057      159558.74      159558.74     -225.13853     -225.13853    
Loop time of 582.893 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 580.98     | 580.98     | 580.98     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25668    | 0.25668    | 0.25668    |   0.0 |  0.04
Output  | 0.00024715 | 0.00024715 | 0.00024715 |   0.0 |  0.00
Modify  | 1.4781     | 1.4781     | 1.4781     |   0.0 |  0.25
Other   |            | 0.1735     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685920 ave      685920 max      685920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685920
Ave neighs/atom = 85.74
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 = 253.387547560741, Press = 1.88067887773837
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -36505.689     -36505.689     -36771.053     -36771.053      256.65057      256.65057      159558.74      159558.74     -225.13853     -225.13853    
     14000  -36513.934     -36513.934     -36775.021     -36775.021      252.51356      252.51356      159605.59      159605.59     -550.67642     -550.67642    
Loop time of 579.648 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.013 hours/ns, 1.725 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 577.76     | 577.76     | 577.76     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25624    | 0.25624    | 0.25624    |   0.0 |  0.04
Output  | 0.00024019 | 0.00024019 | 0.00024019 |   0.0 |  0.00
Modify  | 1.4566     | 1.4566     | 1.4566     |   0.0 |  0.25
Other   |            | 0.172      |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685936 ave      685936 max      685936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685936
Ave neighs/atom = 85.742
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 = 253.427501785516, Press = -1.04195181427383
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -36513.934     -36513.934     -36775.021     -36775.021      252.51356      252.51356      159605.59      159605.59     -550.67642     -550.67642    
     15000  -36507.726     -36507.726     -36772.286     -36772.286      255.87346      255.87346      159548.91      159548.91     -170.25296     -170.25296    
Loop time of 580.568 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.269 hours/ns, 1.722 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 578.67     | 578.67     | 578.67     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25488    | 0.25488    | 0.25488    |   0.0 |  0.04
Output  | 0.00024734 | 0.00024734 | 0.00024734 |   0.0 |  0.00
Modify  | 1.4683     | 1.4683     | 1.4683     |   0.0 |  0.25
Other   |            | 0.1727     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685886 ave      685886 max      685886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685886
Ave neighs/atom = 85.73575
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 = 253.395820395207, Press = 0.101312297956959
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -36507.726     -36507.726     -36772.286     -36772.286      255.87346      255.87346      159548.91      159548.91     -170.25296     -170.25296    
     16000  -36509.167     -36509.167     -36773.407     -36773.407      255.56332      255.56332      159522.78      159522.78     -33.420954     -33.420954    
Loop time of 580.275 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.188 hours/ns, 1.723 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 578.4      | 578.4      | 578.4      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25373    | 0.25373    | 0.25373    |   0.0 |  0.04
Output  | 0.00023552 | 0.00023552 | 0.00023552 |   0.0 |  0.00
Modify  | 1.447      | 1.447      | 1.447      |   0.0 |  0.25
Other   |            | 0.1707     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686044 ave      686044 max      686044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686044
Ave neighs/atom = 85.7555
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 = 253.372868221913, Press = -0.305292544317173
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -36509.167     -36509.167     -36773.407     -36773.407      255.56332      255.56332      159522.78      159522.78     -33.420954     -33.420954    
     17000  -36508.448     -36508.448     -36768.734     -36768.734      251.73916      251.73916      159522.83      159522.83     -118.92555     -118.92555    
Loop time of 580.963 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.379 hours/ns, 1.721 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 579.08     | 579.08     | 579.08     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25473    | 0.25473    | 0.25473    |   0.0 |  0.04
Output  | 0.00023872 | 0.00023872 | 0.00023872 |   0.0 |  0.00
Modify  | 1.4583     | 1.4583     | 1.4583     |   0.0 |  0.25
Other   |            | 0.1722     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686026 ave      686026 max      686026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686026
Ave neighs/atom = 85.75325
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 = 253.448677703205, Press = 1.25659174789318
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -36508.448     -36508.448     -36768.734     -36768.734      251.73916      251.73916      159522.83      159522.83     -118.92555     -118.92555    
     18000  -36507.357     -36507.357     -36771.983     -36771.983      255.93593      255.93593      159530.99      159530.99     -229.94156     -229.94156    
Loop time of 579.871 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.075 hours/ns, 1.725 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 577.99     | 577.99     | 577.99     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25335    | 0.25335    | 0.25335    |   0.0 |  0.04
Output  | 0.00031592 | 0.00031592 | 0.00031592 |   0.0 |  0.00
Modify  | 1.457      | 1.457      | 1.457      |   0.0 |  0.25
Other   |            | 0.1719     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685978 ave      685978 max      685978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685978
Ave neighs/atom = 85.74725
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 = 253.455920587604, Press = 0.927571378421675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -36507.357     -36507.357     -36771.983     -36771.983      255.93593      255.93593      159530.99      159530.99     -229.94156     -229.94156    
     19000  -36513.8       -36513.8       -36774.428     -36774.428      252.07023      252.07023      159475.07      159475.07      163.05342      163.05342    
Loop time of 576.681 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 574.83     | 574.83     | 574.83     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25023    | 0.25023    | 0.25023    |   0.0 |  0.04
Output  | 0.00024031 | 0.00024031 | 0.00024031 |   0.0 |  0.00
Modify  | 1.4258     | 1.4258     | 1.4258     |   0.0 |  0.25
Other   |            | 0.1705     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685926 ave      685926 max      685926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685926
Ave neighs/atom = 85.74075
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 = 253.502353823386, Press = 2.88220127888698
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -36513.8       -36513.8       -36774.428     -36774.428      252.07023      252.07023      159475.07      159475.07      163.05342      163.05342    
     20000  -36508.948     -36508.948     -36775.031     -36775.031      257.34483      257.34483      159533.76      159533.76     -23.875864     -23.875864    
Loop time of 588.482 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.467 hours/ns, 1.699 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.54     | 586.54     | 586.54     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25883    | 0.25883    | 0.25883    |   0.0 |  0.04
Output  | 0.00024205 | 0.00024205 | 0.00024205 |   0.0 |  0.00
Modify  | 1.5078     | 1.5078     | 1.5078     |   0.0 |  0.26
Other   |            | 0.1758     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686062 ave      686062 max      686062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686062
Ave neighs/atom = 85.75775
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 = 253.467686605122, Press = 1.6100798342375
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -36508.948     -36508.948     -36775.031     -36775.031      257.34483      257.34483      159533.76      159533.76     -23.875864     -23.875864    
     21000  -36514.792     -36514.792     -36771.601     -36771.601      248.37656      248.37656      159525.73      159525.73     -134.29416     -134.29416    
Loop time of 587.581 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.217 hours/ns, 1.702 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.65     | 585.65     | 585.65     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25713    | 0.25713    | 0.25713    |   0.0 |  0.04
Output  | 0.00030023 | 0.00030023 | 0.00030023 |   0.0 |  0.00
Modify  | 1.4954     | 1.4954     | 1.4954     |   0.0 |  0.25
Other   |            | 0.1763     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686082 ave      686082 max      686082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686082
Ave neighs/atom = 85.76025
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 = 253.39222069916, Press = 1.64008749456354
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -36514.792     -36514.792     -36771.601     -36771.601      248.37656      248.37656      159525.73      159525.73     -134.29416     -134.29416    
     22000  -36509.427     -36509.427     -36769.843     -36769.843      251.8646       251.8646       159511.55      159511.55      46.920007      46.920007    
Loop time of 583.487 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 581.58     | 581.58     | 581.58     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2553     | 0.2553     | 0.2553     |   0.0 |  0.04
Output  | 0.00024529 | 0.00024529 | 0.00024529 |   0.0 |  0.00
Modify  | 1.477      | 1.477      | 1.477      |   0.0 |  0.25
Other   |            | 0.1734     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686036 ave      686036 max      686036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686036
Ave neighs/atom = 85.7545
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 = 253.355854183974, Press = 1.83431869602056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -36509.427     -36509.427     -36769.843     -36769.843      251.8646       251.8646       159511.55      159511.55      46.920007      46.920007    
     23000  -36509.921     -36509.921     -36773.293     -36773.293      254.72347      254.72347      159475.91      159475.91      384.11303      384.11303    
Loop time of 580.26 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.183 hours/ns, 1.723 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 578.37     | 578.37     | 578.37     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25293    | 0.25293    | 0.25293    |   0.0 |  0.04
Output  | 0.00031505 | 0.00031505 | 0.00031505 |   0.0 |  0.00
Modify  | 1.4612     | 1.4612     | 1.4612     |   0.0 |  0.25
Other   |            | 0.1739     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686080 ave      686080 max      686080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686080
Ave neighs/atom = 85.76
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 = 253.344039642609, Press = 1.24955019047192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -36509.921     -36509.921     -36773.293     -36773.293      254.72347      254.72347      159475.91      159475.91      384.11303      384.11303    
     24000  -36513.537     -36513.537     -36774.527     -36774.527      252.41958      252.41958      159490.75      159490.75      142.22399      142.22399    
Loop time of 587.723 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.256 hours/ns, 1.701 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.79     | 585.79     | 585.79     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25635    | 0.25635    | 0.25635    |   0.0 |  0.04
Output  | 0.00028858 | 0.00028858 | 0.00028858 |   0.0 |  0.00
Modify  | 1.4954     | 1.4954     | 1.4954     |   0.0 |  0.25
Other   |            | 0.176      |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686162 ave      686162 max      686162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686162
Ave neighs/atom = 85.77025
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 = 253.339642874623, Press = 0.861433129143819
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -36513.537     -36513.537     -36774.527     -36774.527      252.41958      252.41958      159490.75      159490.75      142.22399      142.22399    
     25000  -36509.38      -36509.38      -36769.618     -36769.618      251.69224      251.69224      159671.26      159671.26     -1040.9534     -1040.9534    
Loop time of 586.221 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 162.839 hours/ns, 1.706 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 584.31     | 584.31     | 584.31     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25506    | 0.25506    | 0.25506    |   0.0 |  0.04
Output  | 0.00023818 | 0.00023818 | 0.00023818 |   0.0 |  0.00
Modify  | 1.48       | 1.48       | 1.48       |   0.0 |  0.25
Other   |            | 0.1733     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686124 ave      686124 max      686124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686124
Ave neighs/atom = 85.7655
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 = 253.371349335198, Press = 0.0300981645633817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -36509.38      -36509.38      -36769.618     -36769.618      251.69224      251.69224      159671.26      159671.26     -1040.9534     -1040.9534    
     26000  -36508.484     -36508.484     -36768.765     -36768.765      251.73377      251.73377      159636.84      159636.84     -767.53483     -767.53483    
Loop time of 579.027 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 160.841 hours/ns, 1.727 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 577.16     | 577.16     | 577.16     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2534     | 0.2534     | 0.2534     |   0.0 |  0.04
Output  | 0.00023886 | 0.00023886 | 0.00023886 |   0.0 |  0.00
Modify  | 1.4471     | 1.4471     | 1.4471     |   0.0 |  0.25
Other   |            | 0.1715     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685800 ave      685800 max      685800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685800
Ave neighs/atom = 85.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 = 253.382791003494, Press = 0.608167925401376
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -36508.484     -36508.484     -36768.765     -36768.765      251.73377      251.73377      159636.84      159636.84     -767.53483     -767.53483    
     27000  -36509.065     -36509.065     -36771.295     -36771.295      253.61923      253.61923      159640.53      159640.53     -648.68623     -648.68623    
Loop time of 577.938 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 160.538 hours/ns, 1.730 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 576.07     | 576.07     | 576.07     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25501    | 0.25501    | 0.25501    |   0.0 |  0.04
Output  | 0.00024113 | 0.00024113 | 0.00024113 |   0.0 |  0.00
Modify  | 1.4412     | 1.4412     | 1.4412     |   0.0 |  0.25
Other   |            | 0.1703     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685914 ave      685914 max      685914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685914
Ave neighs/atom = 85.73925
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 = 253.433841507137, Press = 0.685679176038836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -36509.065     -36509.065     -36771.295     -36771.295      253.61923      253.61923      159640.53      159640.53     -648.68623     -648.68623    
     28000  -36505.583     -36505.583     -36767.729     -36767.729      253.53775      253.53775      159537.67      159537.67     -286.82712     -286.82712    
Loop time of 583.528 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 162.091 hours/ns, 1.714 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 581.63     | 581.63     | 581.63     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25479    | 0.25479    | 0.25479    |   0.0 |  0.04
Output  | 0.00031033 | 0.00031033 | 0.00031033 |   0.0 |  0.00
Modify  | 1.4732     | 1.4732     | 1.4732     |   0.0 |  0.25
Other   |            | 0.1727     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686006 ave      686006 max      686006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686006
Ave neighs/atom = 85.75075
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 = 253.433313781688, Press = 1.0395096363015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -36505.583     -36505.583     -36767.729     -36767.729      253.53775      253.53775      159537.67      159537.67     -286.82712     -286.82712    
     29000  -36510.589     -36510.589     -36772.369     -36772.369      253.18407      253.18407      159563.14      159563.14     -211.39164     -211.39164    
Loop time of 585.723 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 583.8      | 583.8      | 583.8      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25734    | 0.25734    | 0.25734    |   0.0 |  0.04
Output  | 0.00024014 | 0.00024014 | 0.00024014 |   0.0 |  0.00
Modify  | 1.489      | 1.489      | 1.489      |   0.0 |  0.25
Other   |            | 0.1738     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685836 ave      685836 max      685836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685836
Ave neighs/atom = 85.7295
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 = 253.454105664089, Press = 0.616311193747392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -36510.589     -36510.589     -36772.369     -36772.369      253.18407      253.18407      159563.14      159563.14     -211.39164     -211.39164    
     30000  -36507.946     -36507.946     -36768.834     -36768.834      252.32161      252.32161      159453.29      159453.29      215.59932      215.59932    
Loop time of 576.044 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 160.012 hours/ns, 1.736 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 574.19     | 574.19     | 574.19     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24839    | 0.24839    | 0.24839    |   0.0 |  0.04
Output  | 0.00023983 | 0.00023983 | 0.00023983 |   0.0 |  0.00
Modify  | 1.4314     | 1.4314     | 1.4314     |   0.0 |  0.25
Other   |            | 0.1707     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686038 ave      686038 max      686038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686038
Ave neighs/atom = 85.75475
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 = 253.41275144829, Press = 1.04873961838071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -36507.946     -36507.946     -36768.834     -36768.834      252.32161      252.32161      159453.29      159453.29      215.59932      215.59932    
     31000  -36516.226     -36516.226     -36774.356     -36774.356      249.65342      249.65342      159517.81      159517.81      146.07595      146.07595    
Loop time of 568.725 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.152 ns/day, 157.979 hours/ns, 1.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 566.9      | 566.9      | 566.9      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24947    | 0.24947    | 0.24947    |   0.0 |  0.04
Output  | 0.00024145 | 0.00024145 | 0.00024145 |   0.0 |  0.00
Modify  | 1.4038     | 1.4038     | 1.4038     |   0.0 |  0.25
Other   |            | 0.1691     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685968 ave      685968 max      685968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685968
Ave neighs/atom = 85.746
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 = 253.373341518005, Press = 1.43233443905145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -36516.226     -36516.226     -36774.356     -36774.356      249.65342      249.65342      159517.81      159517.81      146.07595      146.07595    
     32000  -36507.39      -36507.39      -36768.707     -36768.707      252.73646      252.73646      159395.81      159395.81      555.03954      555.03954    
Loop time of 568.823 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.152 ns/day, 158.006 hours/ns, 1.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 567        | 567        | 567        |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2472     | 0.2472     | 0.2472     |   0.0 |  0.04
Output  | 0.00029    | 0.00029    | 0.00029    |   0.0 |  0.00
Modify  | 1.4093     | 1.4093     | 1.4093     |   0.0 |  0.25
Other   |            | 0.1686     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686046 ave      686046 max      686046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686046
Ave neighs/atom = 85.75575
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 = 253.345861564716, Press = 1.44263656435987
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -36507.39      -36507.39      -36768.707     -36768.707      252.73646      252.73646      159395.81      159395.81      555.03954      555.03954    
     33000  -36503.447     -36503.447     -36767.474     -36767.474      255.35753      255.35753      159399.61      159399.61      558.14461      558.14461    
Loop time of 575.501 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 159.861 hours/ns, 1.738 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 573.63     | 573.63     | 573.63     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25205    | 0.25205    | 0.25205    |   0.0 |  0.04
Output  | 0.00023457 | 0.00023457 | 0.00023457 |   0.0 |  0.00
Modify  | 1.4444     | 1.4444     | 1.4444     |   0.0 |  0.25
Other   |            | 0.1711     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686116 ave      686116 max      686116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686116
Ave neighs/atom = 85.7645
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 = 253.340580776922, Press = 1.21970303022368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -36503.447     -36503.447     -36767.474     -36767.474      255.35753      255.35753      159399.61      159399.61      558.14461      558.14461    
     34000  -36511.675     -36511.675     -36771.756     -36771.756      251.54088      251.54088      159467.12      159467.12      28.710521      28.710521    
Loop time of 576.021 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 160.006 hours/ns, 1.736 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 574.16     | 574.16     | 574.16     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25083    | 0.25083    | 0.25083    |   0.0 |  0.04
Output  | 0.00023684 | 0.00023684 | 0.00023684 |   0.0 |  0.00
Modify  | 1.4401     | 1.4401     | 1.4401     |   0.0 |  0.25
Other   |            | 0.1709     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685980 ave      685980 max      685980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685980
Ave neighs/atom = 85.7475
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 = 253.36766729334, Press = 0.831499949485827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -36511.675     -36511.675     -36771.756     -36771.756      251.54088      251.54088      159467.12      159467.12      28.710521      28.710521    
     35000  -36506.199     -36506.199     -36770.585     -36770.585      255.70385      255.70385      159462.7       159462.7       188.55037      188.55037    
Loop time of 575.369 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 159.825 hours/ns, 1.738 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 573.51     | 573.51     | 573.51     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24994    | 0.24994    | 0.24994    |   0.0 |  0.04
Output  | 0.00023678 | 0.00023678 | 0.00023678 |   0.0 |  0.00
Modify  | 1.4409     | 1.4409     | 1.4409     |   0.0 |  0.25
Other   |            | 0.1714     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686046 ave      686046 max      686046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686046
Ave neighs/atom = 85.75575
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 = 253.38447985046, Press = 0.675081107939989
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -36506.199     -36506.199     -36770.585     -36770.585      255.70385      255.70385      159462.7       159462.7       188.55037      188.55037    
     36000  -36511.938     -36511.938     -36772.87      -36772.87       252.36423      252.36423      159521.66      159521.66      16.65046       16.65046     
Loop time of 571.296 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 158.693 hours/ns, 1.750 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 569.46     | 569.46     | 569.46     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24756    | 0.24756    | 0.24756    |   0.0 |  0.04
Output  | 0.00023948 | 0.00023948 | 0.00023948 |   0.0 |  0.00
Modify  | 1.4184     | 1.4184     | 1.4184     |   0.0 |  0.25
Other   |            | 0.1696     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685994 ave      685994 max      685994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685994
Ave neighs/atom = 85.74925
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 = 253.392439272816, Press = 0.630180599062793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -36511.938     -36511.938     -36772.87      -36772.87       252.36423      252.36423      159521.66      159521.66      16.65046       16.65046     
     37000  -36504.766     -36504.766     -36770.796     -36770.796      257.29434      257.29434      159499.74      159499.74      85.36693       85.36693     
Loop time of 572.679 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 159.078 hours/ns, 1.746 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 570.83     | 570.83     | 570.83     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25128    | 0.25128    | 0.25128    |   0.0 |  0.04
Output  | 0.00036012 | 0.00036012 | 0.00036012 |   0.0 |  0.00
Modify  | 1.4286     | 1.4286     | 1.4286     |   0.0 |  0.25
Other   |            | 0.17       |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686122 ave      686122 max      686122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686122
Ave neighs/atom = 85.76525
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 = 253.394825151467, Press = 0.451660612719024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -36504.766     -36504.766     -36770.796     -36770.796      257.29434      257.29434      159499.74      159499.74      85.36693       85.36693     
     38000  -36513.064     -36513.064     -36775.664     -36775.664      253.97705      253.97705      159543.91      159543.91     -113.9175      -113.9175     
Loop time of 571.731 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 158.814 hours/ns, 1.749 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 569.89     | 569.89     | 569.89     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24632    | 0.24632    | 0.24632    |   0.0 |  0.04
Output  | 0.00023744 | 0.00023744 | 0.00023744 |   0.0 |  0.00
Modify  | 1.4214     | 1.4214     | 1.4214     |   0.0 |  0.25
Other   |            | 0.1696     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686042 ave      686042 max      686042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686042
Ave neighs/atom = 85.75525
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 = 253.414441426409, Press = 0.277679018792944
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -36513.064     -36513.064     -36775.664     -36775.664      253.97705      253.97705      159543.91      159543.91     -113.9175      -113.9175     
     39000  -36505.902     -36505.902     -36766.363     -36766.363      251.90821      251.90821      159505.9       159505.9      -126.39499     -126.39499    
Loop time of 570.854 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 158.571 hours/ns, 1.752 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 569.04     | 569.04     | 569.04     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24721    | 0.24721    | 0.24721    |   0.0 |  0.04
Output  | 0.00032497 | 0.00032497 | 0.00032497 |   0.0 |  0.00
Modify  | 1.4005     | 1.4005     | 1.4005     |   0.0 |  0.25
Other   |            | 0.1682     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686040 ave      686040 max      686040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686040
Ave neighs/atom = 85.755
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 = 253.42250620663, Press = -0.0277543579573609
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -36505.902     -36505.902     -36766.363     -36766.363      251.90821      251.90821      159505.9       159505.9      -126.39499     -126.39499    
     40000  -36511.68      -36511.68      -36772.114     -36772.114      251.88172      251.88172      159528.06      159528.06      12.464875      12.464875    
Loop time of 568.574 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.152 ns/day, 157.937 hours/ns, 1.759 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 566.76     | 566.76     | 566.76     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24513    | 0.24513    | 0.24513    |   0.0 |  0.04
Output  | 0.00023442 | 0.00023442 | 0.00023442 |   0.0 |  0.00
Modify  | 1.3977     | 1.3977     | 1.3977     |   0.0 |  0.25
Other   |            | 0.1671     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685742 ave      685742 max      685742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685742
Ave neighs/atom = 85.71775
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 = 253.423276249913, Press = 0.0675305355439602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -36511.68      -36511.68      -36772.114     -36772.114      251.88172      251.88172      159528.06      159528.06      12.464875      12.464875    
     41000  -36507.88      -36507.88      -36769.184     -36769.184      252.72366      252.72366      159353.79      159353.79      549.52912      549.52912    
Loop time of 572.371 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 158.992 hours/ns, 1.747 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 570.53     | 570.53     | 570.53     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24782    | 0.24782    | 0.24782    |   0.0 |  0.04
Output  | 0.00023893 | 0.00023893 | 0.00023893 |   0.0 |  0.00
Modify  | 1.4252     | 1.4252     | 1.4252     |   0.0 |  0.25
Other   |            | 0.1696     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686030 ave      686030 max      686030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686030
Ave neighs/atom = 85.75375
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 = 253.416991842013, Press = -0.172984142920649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -36507.88      -36507.88      -36769.184     -36769.184      252.72366      252.72366      159353.79      159353.79      549.52912      549.52912    
     42000  -36508.048     -36508.048     -36769.985     -36769.985      253.33652      253.33652      159420.95      159420.95      346.25494      346.25494    
Loop time of 570.693 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 158.526 hours/ns, 1.752 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 568.85     | 568.85     | 568.85     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24919    | 0.24919    | 0.24919    |   0.0 |  0.04
Output  | 0.00028675 | 0.00028675 | 0.00028675 |   0.0 |  0.00
Modify  | 1.4198     | 1.4198     | 1.4198     |   0.0 |  0.25
Other   |            | 0.1689     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686044 ave      686044 max      686044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686044
Ave neighs/atom = 85.7555
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 = 253.416004983574, Press = 0.248966247851685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -36508.048     -36508.048     -36769.985     -36769.985      253.33652      253.33652      159420.95      159420.95      346.25494      346.25494    
     43000  -36506.044     -36506.044     -36770.551     -36770.551      255.82166      255.82166      159433.8       159433.8       392.46873      392.46873    
Loop time of 582.993 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 161.943 hours/ns, 1.715 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 581.08     | 581.08     | 581.08     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25315    | 0.25315    | 0.25315    |   0.0 |  0.04
Output  | 0.00029555 | 0.00029555 | 0.00029555 |   0.0 |  0.00
Modify  | 1.483      | 1.483      | 1.483      |   0.0 |  0.25
Other   |            | 0.1747     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685882 ave      685882 max      685882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685882
Ave neighs/atom = 85.73525
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 = 253.405260946051, Press = 0.355719155650861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -36506.044     -36506.044     -36770.551     -36770.551      255.82166      255.82166      159433.8       159433.8       392.46873      392.46873    
     44000  -36513.943     -36513.943     -36773.419     -36773.419      250.95498      250.95498      159421.15      159421.15      537.37948      537.37948    
Loop time of 573.495 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 159.304 hours/ns, 1.744 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 571.65     | 571.65     | 571.65     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24745    | 0.24745    | 0.24745    |   0.0 |  0.04
Output  | 0.00030412 | 0.00030412 | 0.00030412 |   0.0 |  0.00
Modify  | 1.4273     | 1.4273     | 1.4273     |   0.0 |  0.25
Other   |            | 0.1697     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686062 ave      686062 max      686062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686062
Ave neighs/atom = 85.75775
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 = 253.403051889973, Press = 0.372462027319777
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -36513.943     -36513.943     -36773.419     -36773.419      250.95498      250.95498      159421.15      159421.15      537.37948      537.37948    
     45000  -36511.025     -36511.025     -36773.861     -36773.861      254.20555      254.20555      159448.85      159448.85      258.16057      258.16057    
Loop time of 572.298 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 158.972 hours/ns, 1.747 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 570.45     | 570.45     | 570.45     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2507     | 0.2507     | 0.2507     |   0.0 |  0.04
Output  | 0.00023829 | 0.00023829 | 0.00023829 |   0.0 |  0.00
Modify  | 1.4303     | 1.4303     | 1.4303     |   0.0 |  0.25
Other   |            | 0.1704     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686118 ave      686118 max      686118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686118
Ave neighs/atom = 85.76475
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 = 253.412039569493, Press = 0.462233583329696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -36511.025     -36511.025     -36773.861     -36773.861      254.20555      254.20555      159448.85      159448.85      258.16057      258.16057    
     46000  -36512.415     -36512.415     -36777.112     -36777.112      256.00555      256.00555      159371.39      159371.39      719.4919       719.4919     
Loop time of 568.83 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.152 ns/day, 158.008 hours/ns, 1.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 567        | 567        | 567        |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24819    | 0.24819    | 0.24819    |   0.0 |  0.04
Output  | 0.00023951 | 0.00023951 | 0.00023951 |   0.0 |  0.00
Modify  | 1.4147     | 1.4147     | 1.4147     |   0.0 |  0.25
Other   |            | 0.168      |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686044 ave      686044 max      686044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686044
Ave neighs/atom = 85.7555
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 = 253.428124875169, Press = 0.186515997642414
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -36512.415     -36512.415     -36777.112     -36777.112      256.00555      256.00555      159371.39      159371.39      719.4919       719.4919     
     47000  -36505.146     -36505.146     -36769.315     -36769.315      255.49457      255.49457      159424.2       159424.2       291.9537       291.9537     
Loop time of 578.855 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 160.793 hours/ns, 1.728 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 576.99     | 576.99     | 576.99     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25003    | 0.25003    | 0.25003    |   0.0 |  0.04
Output  | 0.00028055 | 0.00028055 | 0.00028055 |   0.0 |  0.00
Modify  | 1.446      | 1.446      | 1.446      |   0.0 |  0.25
Other   |            | 0.1732     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686186 ave      686186 max      686186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686186
Ave neighs/atom = 85.77325
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 = 253.44715679831, Press = 0.288499007417884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -36505.146     -36505.146     -36769.315     -36769.315      255.49457      255.49457      159424.2       159424.2       291.9537       291.9537     
     48000  -36507.274     -36507.274     -36770.907     -36770.907      254.97664      254.97664      159405.39      159405.39      474.51202      474.51202    
Loop time of 573.768 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 159.380 hours/ns, 1.743 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 571.93     | 571.93     | 571.93     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24696    | 0.24696    | 0.24696    |   0.0 |  0.04
Output  | 0.000241   | 0.000241   | 0.000241   |   0.0 |  0.00
Modify  | 1.4164     | 1.4164     | 1.4164     |   0.0 |  0.25
Other   |            | 0.1703     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685928 ave      685928 max      685928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685928
Ave neighs/atom = 85.741
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 = 253.449614149528, Press = 0.456058845114675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -36507.274     -36507.274     -36770.907     -36770.907      254.97664      254.97664      159405.39      159405.39      474.51202      474.51202    
     49000  -36512.514     -36512.514     -36770.516     -36770.516      249.52948      249.52948      159324.66      159324.66      877.57346      877.57346    
Loop time of 580.957 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.377 hours/ns, 1.721 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 579.07     | 579.07     | 579.07     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25278    | 0.25278    | 0.25278    |   0.0 |  0.04
Output  | 0.00031366 | 0.00031366 | 0.00031366 |   0.0 |  0.00
Modify  | 1.4645     | 1.4645     | 1.4645     |   0.0 |  0.25
Other   |            | 0.1725     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685998 ave      685998 max      685998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685998
Ave neighs/atom = 85.74975
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 = 253.445431719373, Press = 0.331691746432815
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -36512.514     -36512.514     -36770.516     -36770.516      249.52948      249.52948      159324.66      159324.66      877.57346      877.57346    
     50000  -36507.728     -36507.728     -36772.638     -36772.638      256.2111       256.2111       159409.44      159409.44      378.07002      378.07002    
Loop time of 574.345 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 159.540 hours/ns, 1.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 572.49     | 572.49     | 572.49     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24853    | 0.24853    | 0.24853    |   0.0 |  0.04
Output  | 0.00024453 | 0.00024453 | 0.00024453 |   0.0 |  0.00
Modify  | 1.432      | 1.432      | 1.432      |   0.0 |  0.25
Other   |            | 0.1697     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685992 ave      685992 max      685992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685992
Ave neighs/atom = 85.749
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.413327552764, Press = 0.745533994851306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -36507.728     -36507.728     -36772.638     -36772.638      256.2111       256.2111       159409.44      159409.44      378.07002      378.07002    
     51000  -36514.001     -36514.001     -36771.706     -36771.706      249.24208      249.24208      159462.85      159462.85      71.442349      71.442349    
Loop time of 578.182 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 160.606 hours/ns, 1.730 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 576.32     | 576.32     | 576.32     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25056    | 0.25056    | 0.25056    |   0.0 |  0.04
Output  | 0.00023652 | 0.00023652 | 0.00023652 |   0.0 |  0.00
Modify  | 1.4409     | 1.4409     | 1.4409     |   0.0 |  0.25
Other   |            | 0.1714     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685836 ave      685836 max      685836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685836
Ave neighs/atom = 85.7295
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 = 253.398649189879, Press = 0.504330676364573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -36514.001     -36514.001     -36771.706     -36771.706      249.24208      249.24208      159462.85      159462.85      71.442349      71.442349    
     52000  -36508.618     -36508.618     -36770.87      -36770.87       253.63982      253.63982      159407.41      159407.41      475.79926      475.79926    
Loop time of 568.433 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.152 ns/day, 157.898 hours/ns, 1.759 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 566.61     | 566.61     | 566.61     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24736    | 0.24736    | 0.24736    |   0.0 |  0.04
Output  | 0.00023607 | 0.00023607 | 0.00023607 |   0.0 |  0.00
Modify  | 1.4027     | 1.4027     | 1.4027     |   0.0 |  0.25
Other   |            | 0.1678     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685976 ave      685976 max      685976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685976
Ave neighs/atom = 85.747
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 = 253.407793692944, Press = 0.49295479231489
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -36508.618     -36508.618     -36770.87      -36770.87       253.63982      253.63982      159407.41      159407.41      475.79926      475.79926    
     53000  -36509.146     -36509.146     -36770.848     -36770.848      253.10779      253.10779      159399.66      159399.66      288.65494      288.65494    
Loop time of 574.107 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 159.474 hours/ns, 1.742 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 572.25     | 572.25     | 572.25     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2499     | 0.2499     | 0.2499     |   0.0 |  0.04
Output  | 0.00028252 | 0.00028252 | 0.00028252 |   0.0 |  0.00
Modify  | 1.4378     | 1.4378     | 1.4378     |   0.0 |  0.25
Other   |            | 0.1698     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685974 ave      685974 max      685974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685974
Ave neighs/atom = 85.74675
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 = 253.403351553641, Press = 0.765134293612751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -36509.146     -36509.146     -36770.848     -36770.848      253.10779      253.10779      159399.66      159399.66      288.65494      288.65494    
     54000  -36511.118     -36511.118     -36772.293     -36772.293      252.59857      252.59857      159515.68      159515.68     -91.567306     -91.567306    
Loop time of 576.657 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 574.78     | 574.78     | 574.78     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25144    | 0.25144    | 0.25144    |   0.0 |  0.04
Output  | 0.00025076 | 0.00025076 | 0.00025076 |   0.0 |  0.00
Modify  | 1.4483     | 1.4483     | 1.4483     |   0.0 |  0.25
Other   |            | 0.1719     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685882 ave      685882 max      685882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685882
Ave neighs/atom = 85.73525
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 = 253.394827277315, Press = 0.443635991611818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -36511.118     -36511.118     -36772.293     -36772.293      252.59857      252.59857      159515.68      159515.68     -91.567306     -91.567306    
     55000  -36508.271     -36508.271     -36771.598     -36771.598      254.6796       254.6796       159622         159622        -654.89523     -654.89523    
Loop time of 577.157 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 160.321 hours/ns, 1.733 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 575.29     | 575.29     | 575.29     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24906    | 0.24906    | 0.24906    |   0.0 |  0.04
Output  | 0.0003441  | 0.0003441  | 0.0003441  |   0.0 |  0.00
Modify  | 1.4445     | 1.4445     | 1.4445     |   0.0 |  0.25
Other   |            | 0.1711     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685966 ave      685966 max      685966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685966
Ave neighs/atom = 85.74575
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 = 253.370250324968, Press = 0.414488243182088
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -36508.271     -36508.271     -36771.598     -36771.598      254.6796       254.6796       159622         159622        -654.89523     -654.89523    
     56000  -36512.77      -36512.77      -36776.491     -36776.491      255.0612       255.0612       159569.51      159569.51     -206.75134     -206.75134    
Loop time of 574.402 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 159.556 hours/ns, 1.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 572.56     | 572.56     | 572.56     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24872    | 0.24872    | 0.24872    |   0.0 |  0.04
Output  | 0.00023696 | 0.00023696 | 0.00023696 |   0.0 |  0.00
Modify  | 1.4223     | 1.4223     | 1.4223     |   0.0 |  0.25
Other   |            | 0.1706     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685880 ave      685880 max      685880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685880
Ave neighs/atom = 85.735
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 = 253.357034082628, Press = -0.00558352250989138
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -36512.77      -36512.77      -36776.491     -36776.491      255.0612       255.0612       159569.51      159569.51     -206.75134     -206.75134    
     57000  -36509.258     -36509.258     -36772.907     -36772.907      254.99172      254.99172      159540.17      159540.17     -341.41072     -341.41072    
Loop time of 569.827 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.152 ns/day, 158.285 hours/ns, 1.755 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 568.02     | 568.02     | 568.02     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.24428    | 0.24428    | 0.24428    |   0.0 |  0.04
Output  | 0.00030264 | 0.00030264 | 0.00030264 |   0.0 |  0.00
Modify  | 1.3942     | 1.3942     | 1.3942     |   0.0 |  0.24
Other   |            | 0.1677     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686014 ave      686014 max      686014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686014
Ave neighs/atom = 85.75175
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
159505.004748672

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0