# 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.430949784815312*${_u_distance}
variable latticeconst_converted equal 5.430949784815312*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.43094978481531
Lattice spacing in x,y,z = 5.4309498 5.4309498 5.4309498
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (54.309498 54.309498 54.309498)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  create_atoms CPU = 0.001 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 SW_StillingerWeber_1985_Si__MO_405512056662_006
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 160187.034626825    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 160187.034626825/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 160187.034626825/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 160187.034626825/(1*1*${_u_distance})
variable      V0_metal equal 160187.034626825/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 160187.034626825*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 160187.034626825 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 293.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "293.15 - 0.2"
variable      T_up  equal  "293.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_405512056662_006#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.307 | 4.307 | 4.307 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -34388.097   -34388.097     -34691.2     -34691.2       293.15       293.15    160187.03    160187.03    2021.0693    2021.0693 
    1000   -34059.289   -34059.289   -34373.892   -34373.892    304.27227    304.27227     160698.4     160698.4    467.54539    467.54539 
Loop time of 11.3832 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.590 ns/day, 3.162 hours/ns, 87.849 timesteps/s
98.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    | 11.003     | 11.003     | 11.003     |   0.0 | 96.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046615   | 0.046615   | 0.046615   |   0.0 |  0.41
Output  | 4.7e-05    | 4.7e-05    | 4.7e-05    |   0.0 |  0.00
Modify  | 0.30029    | 0.30029    | 0.30029    |   0.0 |  2.64
Other   |            | 0.0328     |            |       |  0.29

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      272000.0 ave      272000 max      272000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272000
Ave neighs/atom = 34.000000
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -34059.289   -34059.289   -34373.892   -34373.892    304.27227    304.27227     160698.4     160698.4    467.54539    467.54539 
    2000   -34090.938   -34090.938   -34380.587   -34380.587    280.13805    280.13805    160768.15    160768.15   -208.11589   -208.11589 
Loop time of 11.8228 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.308 ns/day, 3.284 hours/ns, 84.582 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    | 11.46      | 11.46      | 11.46      |   0.0 | 96.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043281   | 0.043281   | 0.043281   |   0.0 |  0.37
Output  | 7.15e-05   | 7.15e-05   | 7.15e-05   |   0.0 |  0.00
Modify  | 0.28818    | 0.28818    | 0.28818    |   0.0 |  2.44
Other   |            | 0.03125    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274878.0 ave      274878 max      274878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274878
Ave neighs/atom = 34.359750
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -34090.938   -34090.938   -34380.587   -34380.587    280.13805    280.13805    160768.15    160768.15   -208.11589   -208.11589 
    3000   -34078.856   -34078.856   -34384.439   -34384.439    295.54866    295.54866    160844.85    160844.85   -692.88644   -692.88644 
Loop time of 11.4648 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.536 ns/day, 3.185 hours/ns, 87.223 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    | 11.115     | 11.115     | 11.115     |   0.0 | 96.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040759   | 0.040759   | 0.040759   |   0.0 |  0.36
Output  | 4.35e-05   | 4.35e-05   | 4.35e-05   |   0.0 |  0.00
Modify  | 0.27927    | 0.27927    | 0.27927    |   0.0 |  2.44
Other   |            | 0.02978    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274508.0 ave      274508 max      274508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274508
Ave neighs/atom = 34.313500
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -34078.856   -34078.856   -34384.439   -34384.439    295.54866    295.54866    160844.85    160844.85   -692.88644   -692.88644 
    4000   -34081.184   -34081.184   -34384.588   -34384.588    293.44197    293.44197    160786.55    160786.55   -306.66133   -306.66133 
Loop time of 11.3801 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.592 ns/day, 3.161 hours/ns, 87.873 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    | 11.032     | 11.032     | 11.032     |   0.0 | 96.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040336   | 0.040336   | 0.040336   |   0.0 |  0.35
Output  | 4.42e-05   | 4.42e-05   | 4.42e-05   |   0.0 |  0.00
Modify  | 0.27835    | 0.27835    | 0.27835    |   0.0 |  2.45
Other   |            | 0.02966    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274474.0 ave      274474 max      274474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274474
Ave neighs/atom = 34.309250
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -34081.184   -34081.184   -34384.588   -34384.588    293.44197    293.44197    160786.55    160786.55   -306.66133   -306.66133 
    5000   -34082.956   -34082.956   -34380.955   -34380.955    288.21365    288.21365       160632       160632    644.86759    644.86759 
Loop time of 11.5317 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.492 ns/day, 3.203 hours/ns, 86.717 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    | 11.181     | 11.181     | 11.181     |   0.0 | 96.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040577   | 0.040577   | 0.040577   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.28037    | 0.28037    | 0.28037    |   0.0 |  2.43
Other   |            | 0.02977    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274684.0 ave      274684 max      274684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274684
Ave neighs/atom = 34.335500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.835030726339, Press = -308.343474719714
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -34082.956   -34082.956   -34380.955   -34380.955    288.21365    288.21365       160632       160632    644.86759    644.86759 
    6000   -34077.228   -34077.228   -34390.612   -34390.612    303.09388    303.09388    160679.38    160679.38    458.66171    458.66171 
Loop time of 11.6356 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.426 ns/day, 3.232 hours/ns, 85.943 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    | 11.275     | 11.275     | 11.275     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040726   | 0.040726   | 0.040726   |   0.0 |  0.35
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.28933    | 0.28933    | 0.28933    |   0.0 |  2.49
Other   |            | 0.03016    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274864.0 ave      274864 max      274864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274864
Ave neighs/atom = 34.358000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.765572519347, Press = -17.4485365306421
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -34077.228   -34077.228   -34390.612   -34390.612    303.09388    303.09388    160679.38    160679.38    458.66171    458.66171 
    7000   -34087.061   -34087.061   -34393.215   -34393.215    296.10135    296.10135    160713.05    160713.05    190.25528    190.25528 
Loop time of 11.5523 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.479 ns/day, 3.209 hours/ns, 86.563 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    | 11.195     | 11.195     | 11.195     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040779   | 0.040779   | 0.040779   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.28618    | 0.28618    | 0.28618    |   0.0 |  2.48
Other   |            | 0.02992    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274386.0 ave      274386 max      274386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274386
Ave neighs/atom = 34.298250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.065730510465, Press = -2.46221862028641
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -34087.061   -34087.061   -34393.215   -34393.215    296.10135    296.10135    160713.05    160713.05    190.25528    190.25528 
    8000    -34079.43    -34079.43   -34380.946   -34380.946    291.61521    291.61521    160812.29    160812.29   -444.50549   -444.50549 
Loop time of 11.1765 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.731 ns/day, 3.105 hours/ns, 89.474 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    | 10.828     | 10.828     | 10.828     |   0.0 | 96.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03982    | 0.03982    | 0.03982    |   0.0 |  0.36
Output  | 3.53e-05   | 3.53e-05   | 3.53e-05   |   0.0 |  0.00
Modify  | 0.27987    | 0.27987    | 0.27987    |   0.0 |  2.50
Other   |            | 0.02913    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274402.0 ave      274402 max      274402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274402
Ave neighs/atom = 34.300250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.099126995906, Press = -4.56429865862453
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -34079.43    -34079.43   -34380.946   -34380.946    291.61521    291.61521    160812.29    160812.29   -444.50549   -444.50549 
    9000   -34084.332   -34084.332   -34386.507   -34386.507    292.25277    292.25277    160806.67    160806.67   -366.92007   -366.92007 
Loop time of 11.3456 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.615 ns/day, 3.152 hours/ns, 88.140 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    | 10.994     | 10.994     | 10.994     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040223   | 0.040223   | 0.040223   |   0.0 |  0.35
Output  | 3.59e-05   | 3.59e-05   | 3.59e-05   |   0.0 |  0.00
Modify  | 0.28199    | 0.28199    | 0.28199    |   0.0 |  2.49
Other   |            | 0.0293     |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274804.0 ave      274804 max      274804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274804
Ave neighs/atom = 34.350500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.062677390759, Press = -7.03852859900844
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -34084.332   -34084.332   -34386.507   -34386.507    292.25277    292.25277    160806.67    160806.67   -366.92007   -366.92007 
   10000   -34079.673   -34079.673   -34387.561   -34387.561    297.77774    297.77774    160814.28    160814.28   -453.01853   -453.01853 
Loop time of 11.2434 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.684 ns/day, 3.123 hours/ns, 88.941 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    | 10.893     | 10.893     | 10.893     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040278   | 0.040278   | 0.040278   |   0.0 |  0.36
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.28065    | 0.28065    | 0.28065    |   0.0 |  2.50
Other   |            | 0.02909    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274492.0 ave      274492 max      274492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274492
Ave neighs/atom = 34.311500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.128726094751, Press = -7.47105799752362
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -34079.673   -34079.673   -34387.561   -34387.561    297.77774    297.77774    160814.28    160814.28   -453.01853   -453.01853 
   11000   -34082.703   -34082.703    -34380.05    -34380.05    287.58272    287.58272    160641.02    160641.02    665.45282    665.45282 
Loop time of 11.4165 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.568 ns/day, 3.171 hours/ns, 87.593 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    | 11.062     | 11.062     | 11.062     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040418   | 0.040418   | 0.040418   |   0.0 |  0.35
Output  | 3.64e-05   | 3.64e-05   | 3.64e-05   |   0.0 |  0.00
Modify  | 0.28443    | 0.28443    | 0.28443    |   0.0 |  2.49
Other   |            | 0.02953    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274588.0 ave      274588 max      274588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274588
Ave neighs/atom = 34.323500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.976343485054, Press = -7.31695337189174
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -34082.703   -34082.703    -34380.05    -34380.05    287.58272    287.58272    160641.02    160641.02    665.45282    665.45282 
   12000    -34084.23    -34084.23   -34385.469   -34385.469     291.3466     291.3466    160645.87    160645.87    547.66058    547.66058 
Loop time of 11.4424 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.551 ns/day, 3.178 hours/ns, 87.394 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    | 11.088     | 11.088     | 11.088     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040428   | 0.040428   | 0.040428   |   0.0 |  0.35
Output  | 3.65e-05   | 3.65e-05   | 3.65e-05   |   0.0 |  0.00
Modify  | 0.28425    | 0.28425    | 0.28425    |   0.0 |  2.48
Other   |            | 0.0296     |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      275020.0 ave      275020 max      275020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275020
Ave neighs/atom = 34.377500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.135702025717, Press = -2.84661757095968
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -34084.23    -34084.23   -34385.469   -34385.469     291.3466     291.3466    160645.87    160645.87    547.66058    547.66058 
   13000   -34073.539   -34073.539   -34379.851   -34379.851     296.2543     296.2543    160730.84    160730.84    88.893916    88.893916 
Loop time of 11.5474 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.482 ns/day, 3.208 hours/ns, 86.600 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    | 11.191     | 11.191     | 11.191     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04067    | 0.04067    | 0.04067    |   0.0 |  0.35
Output  | 3.65e-05   | 3.65e-05   | 3.65e-05   |   0.0 |  0.00
Modify  | 0.28562    | 0.28562    | 0.28562    |   0.0 |  2.47
Other   |            | 0.02986    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274724.0 ave      274724 max      274724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274724
Ave neighs/atom = 34.340500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.282460375686, Press = -2.50047834628007
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -34073.539   -34073.539   -34379.851   -34379.851     296.2543     296.2543    160730.84    160730.84    88.893916    88.893916 
   14000   -34083.416   -34083.416   -34390.977   -34390.977    297.46191    297.46191    160702.78    160702.78     270.6798     270.6798 
Loop time of 10.7361 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.048 ns/day, 2.982 hours/ns, 93.144 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    | 10.4       | 10.4       | 10.4       |   0.0 | 96.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038188   | 0.038188   | 0.038188   |   0.0 |  0.36
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.27021    | 0.27021    | 0.27021    |   0.0 |  2.52
Other   |            | 0.02762    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274566.0 ave      274566 max      274566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274566
Ave neighs/atom = 34.320750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.315572029079, Press = -1.07311677369238
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -34083.416   -34083.416   -34390.977   -34390.977    297.46191    297.46191    160702.78    160702.78     270.6798     270.6798 
   15000   -34076.144   -34076.144   -34375.932   -34375.932    289.94352    289.94352    160930.09    160930.09   -1189.8877   -1189.8877 
Loop time of 11.1711 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.734 ns/day, 3.103 hours/ns, 89.517 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    | 10.826     | 10.826     | 10.826     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039353   | 0.039353   | 0.039353   |   0.0 |  0.35
Output  | 3.62e-05   | 3.62e-05   | 3.62e-05   |   0.0 |  0.00
Modify  | 0.27723    | 0.27723    | 0.27723    |   0.0 |  2.48
Other   |            | 0.02854    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274636.0 ave      274636 max      274636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274636
Ave neighs/atom = 34.329500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.403582254661, Press = -0.420591296973265
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -34076.144   -34076.144   -34375.932   -34375.932    289.94352    289.94352    160930.09    160930.09   -1189.8877   -1189.8877 
   16000   -34084.364   -34084.364   -34384.829   -34384.829    290.59813    290.59813    160936.33    160936.33   -1172.4331   -1172.4331 
Loop time of 11.3018 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.645 ns/day, 3.139 hours/ns, 88.482 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    | 10.951     | 10.951     | 10.951     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039704   | 0.039704   | 0.039704   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.28153    | 0.28153    | 0.28153    |   0.0 |  2.49
Other   |            | 0.02902    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274718.0 ave      274718 max      274718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274718
Ave neighs/atom = 34.339750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.480626980943, Press = -2.81471416625535
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -34084.364   -34084.364   -34384.829   -34384.829    290.59813    290.59813    160936.33    160936.33   -1172.4331   -1172.4331 
   17000   -34080.463   -34080.463   -34380.333   -34380.333    290.02252    290.02252     160799.7     160799.7   -374.22363   -374.22363 
Loop time of 10.9194 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.913 ns/day, 3.033 hours/ns, 91.580 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    | 10.578     | 10.578     | 10.578     |   0.0 | 96.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038891   | 0.038891   | 0.038891   |   0.0 |  0.36
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.2745     | 0.2745     | 0.2745     |   0.0 |  2.51
Other   |            | 0.02803    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274414.0 ave      274414 max      274414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274414
Ave neighs/atom = 34.301750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.494273467064, Press = -3.37051991590724
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -34080.463   -34080.463   -34380.333   -34380.333    290.02252    290.02252     160799.7     160799.7   -374.22363   -374.22363 
   18000   -34085.119   -34085.119   -34379.776   -34379.776    284.98152    284.98152    160676.46    160676.46    449.46255    449.46255 
Loop time of 10.8941 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.931 ns/day, 3.026 hours/ns, 91.793 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    | 10.555     | 10.555     | 10.555     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038573   | 0.038573   | 0.038573   |   0.0 |  0.35
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.27234    | 0.27234    | 0.27234    |   0.0 |  2.50
Other   |            | 0.028      |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274716.0 ave      274716 max      274716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274716
Ave neighs/atom = 34.339500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.45480014614, Press = -2.56918552633104
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -34085.119   -34085.119   -34379.776   -34379.776    284.98152    284.98152    160676.46    160676.46    449.46255    449.46255 
   19000   -34081.585   -34081.585   -34388.126   -34388.126    296.47502    296.47502    160696.41    160696.41    296.85889    296.85889 
Loop time of 11.0327 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.831 ns/day, 3.065 hours/ns, 90.639 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    | 10.689     | 10.689     | 10.689     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038793   | 0.038793   | 0.038793   |   0.0 |  0.35
Output  | 4.49e-05   | 4.49e-05   | 4.49e-05   |   0.0 |  0.00
Modify  | 0.27624    | 0.27624    | 0.27624    |   0.0 |  2.50
Other   |            | 0.02841    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274664.0 ave      274664 max      274664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274664
Ave neighs/atom = 34.333000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.476191859074, Press = -1.59918637097427
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -34081.585   -34081.585   -34388.126   -34388.126    296.47502    296.47502    160696.41    160696.41    296.85889    296.85889 
   20000   -34079.994   -34079.994   -34388.515   -34388.515    298.39045    298.39045    160692.32    160692.32    413.93901    413.93901 
Loop time of 10.3831 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.321 ns/day, 2.884 hours/ns, 96.310 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    | 10.056     | 10.056     | 10.056     |   0.0 | 96.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037144   | 0.037144   | 0.037144   |   0.0 |  0.36
Output  | 4.9e-05    | 4.9e-05    | 4.9e-05    |   0.0 |  0.00
Modify  | 0.26391    | 0.26391    | 0.26391    |   0.0 |  2.54
Other   |            | 0.02623    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274568.0 ave      274568 max      274568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274568
Ave neighs/atom = 34.321000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.435190889506, Press = -1.02888196974828
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -34079.994   -34079.994   -34388.515   -34388.515    298.39045    298.39045    160692.32    160692.32    413.93901    413.93901 
   21000   -34084.412   -34084.412    -34385.29    -34385.29    290.99848    290.99848    160726.39    160726.39    123.15466    123.15466 
Loop time of 10.4747 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.248 ns/day, 2.910 hours/ns, 95.468 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    | 10.146     | 10.146     | 10.146     |   0.0 | 96.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0375     | 0.0375     | 0.0375     |   0.0 |  0.36
Output  | 3.57e-05   | 3.57e-05   | 3.57e-05   |   0.0 |  0.00
Modify  | 0.26487    | 0.26487    | 0.26487    |   0.0 |  2.53
Other   |            | 0.02676    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274412.0 ave      274412 max      274412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274412
Ave neighs/atom = 34.301500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.420364434178, Press = 0.0360324914997356
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -34084.412   -34084.412    -34385.29    -34385.29    290.99848    290.99848    160726.39    160726.39    123.15466    123.15466 
   22000    -34081.76    -34081.76   -34382.988   -34382.988    291.33661    291.33661    160957.28    160957.28   -1366.8771   -1366.8771 
Loop time of 10.5762 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.169 ns/day, 2.938 hours/ns, 94.552 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    | 10.245     | 10.245     | 10.245     |   0.0 | 96.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037694   | 0.037694   | 0.037694   |   0.0 |  0.36
Output  | 4.44e-05   | 4.44e-05   | 4.44e-05   |   0.0 |  0.00
Modify  | 0.26688    | 0.26688    | 0.26688    |   0.0 |  2.52
Other   |            | 0.02689    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274598.0 ave      274598 max      274598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274598
Ave neighs/atom = 34.324750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.461372917031, Press = -0.532903523641357
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -34081.76    -34081.76   -34382.988   -34382.988    291.33661    291.33661    160957.28    160957.28   -1366.8771   -1366.8771 
   23000   -34084.377   -34084.377   -34384.349   -34384.349    290.12196    290.12196    160797.39    160797.39   -331.54182   -331.54182 
Loop time of 10.562 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.180 ns/day, 2.934 hours/ns, 94.679 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    | 10.23      | 10.23      | 10.23      |   0.0 | 96.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037622   | 0.037622   | 0.037622   |   0.0 |  0.36
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.26696    | 0.26696    | 0.26696    |   0.0 |  2.53
Other   |            | 0.02768    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274476.0 ave      274476 max      274476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274476
Ave neighs/atom = 34.309500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.452271579104, Press = -1.3764892805577
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -34084.377   -34084.377   -34384.349   -34384.349    290.12196    290.12196    160797.39    160797.39   -331.54182   -331.54182 
   24000   -34081.499   -34081.499   -34385.539   -34385.539    294.05591    294.05591    160810.07    160810.07   -426.34073   -426.34073 
Loop time of 10.3309 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.363 ns/day, 2.870 hours/ns, 96.797 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    | 10.005     | 10.005     | 10.005     |   0.0 | 96.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037127   | 0.037127   | 0.037127   |   0.0 |  0.36
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.26254    | 0.26254    | 0.26254    |   0.0 |  2.54
Other   |            | 0.02648    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274526.0 ave      274526 max      274526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274526
Ave neighs/atom = 34.315750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.430305967287, Press = -1.9965774676338
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -34081.499   -34081.499   -34385.539   -34385.539    294.05591    294.05591    160810.07    160810.07   -426.34073   -426.34073 
   25000   -34083.651   -34083.651   -34385.754   -34385.754    292.18255    292.18255    160695.36    160695.36    313.58152    313.58152 
Loop time of 10.393 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.313 ns/day, 2.887 hours/ns, 96.219 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    | 10.067     | 10.067     | 10.067     |   0.0 | 96.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037095   | 0.037095   | 0.037095   |   0.0 |  0.36
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.26295    | 0.26295    | 0.26295    |   0.0 |  2.53
Other   |            | 0.02638    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274518.0 ave      274518 max      274518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274518
Ave neighs/atom = 34.314750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.416104511093, Press = -1.9233071777986
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -34083.651   -34083.651   -34385.754   -34385.754    292.18255    292.18255    160695.36    160695.36    313.58152    313.58152 
   26000   -34074.467   -34074.467   -34377.823   -34377.823    293.39454    293.39454     160631.2     160631.2    695.53495    695.53495 
Loop time of 10.651 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.112 ns/day, 2.959 hours/ns, 93.888 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    | 10.32      | 10.32      | 10.32      |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037468   | 0.037468   | 0.037468   |   0.0 |  0.35
Output  | 5.42e-05   | 5.42e-05   | 5.42e-05   |   0.0 |  0.00
Modify  | 0.26661    | 0.26661    | 0.26661    |   0.0 |  2.50
Other   |            | 0.02685    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274698.0 ave      274698 max      274698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274698
Ave neighs/atom = 34.337250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.456142605313, Press = -0.840018692301189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -34074.467   -34074.467   -34377.823   -34377.823    293.39454    293.39454     160631.2     160631.2    695.53495    695.53495 
   27000   -34084.769   -34084.769   -34387.651   -34387.651    292.93678    292.93678    160627.54    160627.54    681.60352    681.60352 
Loop time of 10.6302 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.128 ns/day, 2.953 hours/ns, 94.071 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    | 10.298     | 10.298     | 10.298     |   0.0 | 96.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037607   | 0.037607   | 0.037607   |   0.0 |  0.35
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.26778    | 0.26778    | 0.26778    |   0.0 |  2.52
Other   |            | 0.02715    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      275100.0 ave      275100 max      275100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275100
Ave neighs/atom = 34.387500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.443945544595, Press = 0.276811096179378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -34084.769   -34084.769   -34387.651   -34387.651    292.93678    292.93678    160627.54    160627.54    681.60352    681.60352 
   28000   -34076.679   -34076.679   -34377.486   -34377.486    290.93006    290.93006    160818.64    160818.64   -493.51711   -493.51711 
Loop time of 10.3273 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.366 ns/day, 2.869 hours/ns, 96.831 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    | 10.001     | 10.001     | 10.001     |   0.0 | 96.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037088   | 0.037088   | 0.037088   |   0.0 |  0.36
Output  | 4.44e-05   | 4.44e-05   | 4.44e-05   |   0.0 |  0.00
Modify  | 0.26338    | 0.26338    | 0.26338    |   0.0 |  2.55
Other   |            | 0.02622    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274578.0 ave      274578 max      274578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274578
Ave neighs/atom = 34.322250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.437741387797, Press = 0.289145464683165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -34076.679   -34076.679   -34377.486   -34377.486    290.93006    290.93006    160818.64    160818.64   -493.51711   -493.51711 
   29000   -34084.134   -34084.134   -34386.802   -34386.802    292.72919    292.72919    160799.99    160799.99   -337.58367   -337.58367 
Loop time of 10.3943 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.312 ns/day, 2.887 hours/ns, 96.207 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    | 10.067     | 10.067     | 10.067     |   0.0 | 96.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037119   | 0.037119   | 0.037119   |   0.0 |  0.36
Output  | 3.52e-05   | 3.52e-05   | 3.52e-05   |   0.0 |  0.00
Modify  | 0.26383    | 0.26383    | 0.26383    |   0.0 |  2.54
Other   |            | 0.02647    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274838.0 ave      274838 max      274838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274838
Ave neighs/atom = 34.354750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.45557180561, Press = -0.807832856002945
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -34084.134   -34084.134   -34386.802   -34386.802    292.72919    292.72919    160799.99    160799.99   -337.58367   -337.58367 
   30000   -34081.787   -34081.787   -34382.892   -34382.892    291.21785    291.21785    160770.47    160770.47   -207.75515   -207.75515 
Loop time of 10.511 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.220 ns/day, 2.920 hours/ns, 95.138 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    | 10.181     | 10.181     | 10.181     |   0.0 | 96.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037394   | 0.037394   | 0.037394   |   0.0 |  0.36
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.26595    | 0.26595    | 0.26595    |   0.0 |  2.53
Other   |            | 0.02684    |            |       |  0.26

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274464.0 ave      274464 max      274464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274464
Ave neighs/atom = 34.308000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.476072128111, Press = -1.02096243744115
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -34081.787   -34081.787   -34382.892   -34382.892    291.21785    291.21785    160770.47    160770.47   -207.75515   -207.75515 
   31000   -34085.476   -34085.476   -34381.294   -34381.294    286.10412    286.10412    160754.52    160754.52   -152.05287   -152.05287 
Loop time of 9.81137 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.806 ns/day, 2.725 hours/ns, 101.923 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    | 9.4999     | 9.4999     | 9.4999     |   0.0 | 96.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035523   | 0.035523   | 0.035523   |   0.0 |  0.36
Output  | 3.57e-05   | 3.57e-05   | 3.57e-05   |   0.0 |  0.00
Modify  | 0.25191    | 0.25191    | 0.25191    |   0.0 |  2.57
Other   |            | 0.02402    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274628.0 ave      274628 max      274628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274628
Ave neighs/atom = 34.328500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.476668926929, Press = -1.49361024238616
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -34085.476   -34085.476   -34381.294   -34381.294    286.10412    286.10412    160754.52    160754.52   -152.05287   -152.05287 
   32000   -34084.597   -34084.597   -34388.621   -34388.621    294.04076    294.04076    160534.77    160534.77    1267.3792    1267.3792 
Loop time of 10.0392 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.606 ns/day, 2.789 hours/ns, 99.609 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    | 9.7228     | 9.7228     | 9.7228     |   0.0 | 96.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035952   | 0.035952   | 0.035952   |   0.0 |  0.36
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.25583    | 0.25583    | 0.25583    |   0.0 |  2.55
Other   |            | 0.02457    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274794.0 ave      274794 max      274794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274794
Ave neighs/atom = 34.349250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.486083348238, Press = -1.20551419683464
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -34084.597   -34084.597   -34388.621   -34388.621    294.04076    294.04076    160534.77    160534.77    1267.3792    1267.3792 
   33000   -34078.378   -34078.378   -34377.618   -34377.618      289.414      289.414    160665.29    160665.29    435.12555    435.12555 
Loop time of 9.89591 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.731 ns/day, 2.749 hours/ns, 101.052 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    | 9.5821     | 9.5821     | 9.5821     |   0.0 | 96.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035825   | 0.035825   | 0.035825   |   0.0 |  0.36
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.2537     | 0.2537     | 0.2537     |   0.0 |  2.56
Other   |            | 0.02422    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274826.0 ave      274826 max      274826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274826
Ave neighs/atom = 34.353250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.461651921905, Press = -0.212866110226891
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -34078.378   -34078.378   -34377.618   -34377.618      289.414      289.414    160665.29    160665.29    435.12555    435.12555 
   34000   -34085.028   -34085.028   -34385.695   -34385.695    290.79436    290.79436    160738.46    160738.46   -30.511507   -30.511507 
Loop time of 9.8322 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.787 ns/day, 2.731 hours/ns, 101.707 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    | 9.5183     | 9.5183     | 9.5183     |   0.0 | 96.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035791   | 0.035791   | 0.035791   |   0.0 |  0.36
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.25367    | 0.25367    | 0.25367    |   0.0 |  2.58
Other   |            | 0.02438    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274938.0 ave      274938 max      274938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274938
Ave neighs/atom = 34.367250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.42037834934, Press = -0.582277989835602
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -34085.028   -34085.028   -34385.695   -34385.695    290.79436    290.79436    160738.46    160738.46   -30.511507   -30.511507 
   35000   -34085.213   -34085.213   -34384.261   -34384.261    289.22766    289.22766    160793.68    160793.68   -374.10072   -374.10072 
Loop time of 10.0052 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.635 ns/day, 2.779 hours/ns, 99.948 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    | 9.6899     | 9.6899     | 9.6899     |   0.0 | 96.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035884   | 0.035884   | 0.035884   |   0.0 |  0.36
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.25495    | 0.25495    | 0.25495    |   0.0 |  2.55
Other   |            | 0.02444    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274788.0 ave      274788 max      274788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274788
Ave neighs/atom = 34.348500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.409178854063, Press = -0.330509888207387
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -34085.213   -34085.213   -34384.261   -34384.261    289.22766    289.22766    160793.68    160793.68   -374.10072   -374.10072 
   36000   -34084.144   -34084.144   -34386.784   -34386.784     292.7019     292.7019    160830.37    160830.37   -598.96838   -598.96838 
Loop time of 9.85117 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.771 ns/day, 2.736 hours/ns, 101.511 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    | 9.5391     | 9.5391     | 9.5391     |   0.0 | 96.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035581   | 0.035581   | 0.035581   |   0.0 |  0.36
Output  | 3.6e-05    | 3.6e-05    | 3.6e-05    |   0.0 |  0.00
Modify  | 0.25224    | 0.25224    | 0.25224    |   0.0 |  2.56
Other   |            | 0.02419    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274510.0 ave      274510 max      274510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274510
Ave neighs/atom = 34.313750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.339488027791, Press = -0.990357542054279
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -34084.144   -34084.144   -34386.784   -34386.784     292.7019     292.7019    160830.37    160830.37   -598.96838   -598.96838 
   37000   -34081.148   -34081.148   -34384.697   -34384.697    293.58147    293.58147    160744.15    160744.15    21.439145    21.439145 
Loop time of 10.0043 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.636 ns/day, 2.779 hours/ns, 99.957 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    | 9.6887     | 9.6887     | 9.6887     |   0.0 | 96.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035836   | 0.035836   | 0.035836   |   0.0 |  0.36
Output  | 3.53e-05   | 3.53e-05   | 3.53e-05   |   0.0 |  0.00
Modify  | 0.25525    | 0.25525    | 0.25525    |   0.0 |  2.55
Other   |            | 0.02446    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274624.0 ave      274624 max      274624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274624
Ave neighs/atom = 34.328000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.333077208457, Press = -1.45391642760785
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -34081.148   -34081.148   -34384.697   -34384.697    293.58147    293.58147    160744.15    160744.15    21.439145    21.439145 
   38000   -34084.461   -34084.461   -34384.646   -34384.646    290.32804    290.32804    160614.58    160614.58    735.48945    735.48945 
Loop time of 9.88196 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.743 ns/day, 2.745 hours/ns, 101.194 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    | 9.569      | 9.569      | 9.569      |   0.0 | 96.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035703   | 0.035703   | 0.035703   |   0.0 |  0.36
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.25309    | 0.25309    | 0.25309    |   0.0 |  2.56
Other   |            | 0.02414    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274580.0 ave      274580 max      274580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274580
Ave neighs/atom = 34.322500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.293742996634, Press = -0.819748064622611
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -34084.461   -34084.461   -34384.646   -34384.646    290.32804    290.32804    160614.58    160614.58    735.48945    735.48945 
   39000   -34084.355   -34084.355   -34386.437   -34386.437    292.16254    292.16254    160675.31    160675.31    398.86882    398.86882 
Loop time of 9.89602 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.731 ns/day, 2.749 hours/ns, 101.051 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    | 9.5827     | 9.5827     | 9.5827     |   0.0 | 96.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035605   | 0.035605   | 0.035605   |   0.0 |  0.36
Output  | 3.52e-05   | 3.52e-05   | 3.52e-05   |   0.0 |  0.00
Modify  | 0.2534     | 0.2534     | 0.2534     |   0.0 |  2.56
Other   |            | 0.02426    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274772.0 ave      274772 max      274772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274772
Ave neighs/atom = 34.346500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.281061379647, Press = -0.468440015982572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -34084.355   -34084.355   -34386.437   -34386.437    292.16254    292.16254    160675.31    160675.31    398.86882    398.86882 
   40000   -34080.914   -34080.914   -34385.366   -34385.366    294.45381    294.45381    160765.91    160765.91   -152.92287   -152.92287 
Loop time of 10.0478 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.599 ns/day, 2.791 hours/ns, 99.524 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    | 9.731      | 9.731      | 9.731      |   0.0 | 96.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035938   | 0.035938   | 0.035938   |   0.0 |  0.36
Output  | 3.51e-05   | 3.51e-05   | 3.51e-05   |   0.0 |  0.00
Modify  | 0.25635    | 0.25635    | 0.25635    |   0.0 |  2.55
Other   |            | 0.0245     |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274640.0 ave      274640 max      274640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274640
Ave neighs/atom = 34.330000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.261997098263, Press = -0.362324085151763
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -34080.914   -34080.914   -34385.366   -34385.366    294.45381    294.45381    160765.91    160765.91   -152.92287   -152.92287 
   41000   -34083.835   -34083.835   -34387.306   -34387.306    293.50564    293.50564    160745.47    160745.47   -17.107075   -17.107075 
Loop time of 9.99266 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.646 ns/day, 2.776 hours/ns, 100.073 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    | 9.6773     | 9.6773     | 9.6773     |   0.0 | 96.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035918   | 0.035918   | 0.035918   |   0.0 |  0.36
Output  | 3.61e-05   | 3.61e-05   | 3.61e-05   |   0.0 |  0.00
Modify  | 0.25491    | 0.25491    | 0.25491    |   0.0 |  2.55
Other   |            | 0.02448    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274664.0 ave      274664 max      274664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274664
Ave neighs/atom = 34.333000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.259777611652, Press = -0.524767952621751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -34083.835   -34083.835   -34387.306   -34387.306    293.50564    293.50564    160745.47    160745.47   -17.107075   -17.107075 
   42000   -34078.236   -34078.236   -34388.805   -34388.805    300.37082    300.37082    160858.13    160858.13   -672.44095   -672.44095 
Loop time of 9.94508 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.688 ns/day, 2.763 hours/ns, 100.552 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    | 9.63       | 9.63       | 9.63       |   0.0 | 96.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035868   | 0.035868   | 0.035868   |   0.0 |  0.36
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.25469    | 0.25469    | 0.25469    |   0.0 |  2.56
Other   |            | 0.02453    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274582.0 ave      274582 max      274582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274582
Ave neighs/atom = 34.322750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.251182431556, Press = -0.667276243931135
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -34078.236   -34078.236   -34388.805   -34388.805    300.37082    300.37082    160858.13    160858.13   -672.44095   -672.44095 
   43000   -34079.925   -34079.925   -34386.127   -34386.127      296.148      296.148    160802.58    160802.58    -395.4775    -395.4775 
Loop time of 9.93606 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.696 ns/day, 2.760 hours/ns, 100.644 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    | 9.6212     | 9.6212     | 9.6212     |   0.0 | 96.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035668   | 0.035668   | 0.035668   |   0.0 |  0.36
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.25468    | 0.25468    | 0.25468    |   0.0 |  2.56
Other   |            | 0.02445    |            |       |  0.25

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274428.0 ave      274428 max      274428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274428
Ave neighs/atom = 34.303500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.232384435495, Press = -1.4793516136321
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -34079.925   -34079.925   -34386.127   -34386.127      296.148      296.148    160802.58    160802.58    -395.4775    -395.4775 
   44000   -34072.945   -34072.945   -34382.653   -34382.653     299.5377     299.5377    160675.89    160675.89    483.11027    483.11027 
Loop time of 9.99861 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.641 ns/day, 2.777 hours/ns, 100.014 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    | 9.684      | 9.684      | 9.684      |   0.0 | 96.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035729   | 0.035729   | 0.035729   |   0.0 |  0.36
Output  | 3.59e-05   | 3.59e-05   | 3.59e-05   |   0.0 |  0.00
Modify  | 0.25452    | 0.25452    | 0.25452    |   0.0 |  2.55
Other   |            | 0.02433    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274640.0 ave      274640 max      274640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274640
Ave neighs/atom = 34.330000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.232187783576, Press = -0.725550832761757
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -34072.945   -34072.945   -34382.653   -34382.653     299.5377     299.5377    160675.89    160675.89    483.11027    483.11027 
   45000   -34082.273   -34082.273   -34379.017   -34379.017    287.00008    287.00008    160666.26    160666.26    367.95524    367.95524 
Loop time of 10.1408 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.520 ns/day, 2.817 hours/ns, 98.612 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    | 9.8237     | 9.8237     | 9.8237     |   0.0 | 96.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035889   | 0.035889   | 0.035889   |   0.0 |  0.35
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.25645    | 0.25645    | 0.25645    |   0.0 |  2.53
Other   |            | 0.02471    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274706.0 ave      274706 max      274706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274706
Ave neighs/atom = 34.338250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.224720702983, Press = -0.442812197881124
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -34082.273   -34082.273   -34379.017   -34379.017    287.00008    287.00008    160666.26    160666.26    367.95524    367.95524 
   46000   -34082.472   -34082.472   -34388.338   -34388.338    295.82189    295.82189    160672.16    160672.16    428.75597    428.75597 
Loop time of 9.93194 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.699 ns/day, 2.759 hours/ns, 100.685 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    | 9.6184     | 9.6184     | 9.6184     |   0.0 | 96.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035608   | 0.035608   | 0.035608   |   0.0 |  0.36
Output  | 3.61e-05   | 3.61e-05   | 3.61e-05   |   0.0 |  0.00
Modify  | 0.25361    | 0.25361    | 0.25361    |   0.0 |  2.55
Other   |            | 0.02428    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      275172.0 ave      275172 max      275172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275172
Ave neighs/atom = 34.396500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.223345528524, Press = -0.207548515090181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.77118
  ghost atom cutoff = 5.77118
  binsize = 2.88559, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.77118
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.309 | 4.309 | 4.309 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -34082.472   -34082.472   -34388.338   -34388.338    295.82189    295.82189    160672.16    160672.16    428.75597    428.75597 
   47000   -34079.491   -34079.491   -34381.464   -34381.464    292.05679    292.05679    160797.13    160797.13   -376.14697   -376.14697 
Loop time of 10.0945 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.559 ns/day, 2.804 hours/ns, 99.064 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    | 9.7778     | 9.7778     | 9.7778     |   0.0 | 96.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03598    | 0.03598    | 0.03598    |   0.0 |  0.36
Output  | 5.77e-05   | 5.77e-05   | 5.77e-05   |   0.0 |  0.00
Modify  | 0.25605    | 0.25605    | 0.25605    |   0.0 |  2.54
Other   |            | 0.02466    |            |       |  0.24

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      274624.0 ave      274624 max      274624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274624
Ave neighs/atom = 34.328000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
160742.191485033

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0