# 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 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -34367.418   -34367.418     -34691.2     -34691.2       313.15       313.15    160187.03    160187.03    2158.9559    2158.9559 
    1000   -34015.854   -34015.854   -34352.098   -34352.098    325.20342    325.20342    160665.79    160665.79    927.32682    927.32682 
Loop time of 11.7071 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.380 ns/day, 3.252 hours/ns, 85.419 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.324     | 11.324     | 11.324     |   0.0 | 96.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046135   | 0.046135   | 0.046135   |   0.0 |  0.39
Output  | 4.7e-05    | 4.7e-05    | 4.7e-05    |   0.0 |  0.00
Modify  | 0.30335    | 0.30335    | 0.30335    |   0.0 |  2.59
Other   |            | 0.03326    |            |       |  0.28

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   -34015.854   -34015.854   -34352.098   -34352.098    325.20342    325.20342    160665.79    160665.79    927.32682    927.32682 
    2000   -34049.823   -34049.823   -34358.716   -34358.716    298.75017    298.75017    160711.22    160711.22    380.14393    380.14393 
Loop time of 12.125 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.126 ns/day, 3.368 hours/ns, 82.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    | 11.758     | 11.758     | 11.758     |   0.0 | 96.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042755   | 0.042755   | 0.042755   |   0.0 |  0.35
Output  | 7.25e-05   | 7.25e-05   | 7.25e-05   |   0.0 |  0.00
Modify  | 0.29218    | 0.29218    | 0.29218    |   0.0 |  2.41
Other   |            | 0.03153    |            |       |  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:      275378.0 ave      275378 max      275378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275378
Ave neighs/atom = 34.422250
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   -34049.823   -34049.823   -34358.716   -34358.716    298.75017    298.75017    160711.22    160711.22    380.14393    380.14393 
    3000   -34036.766   -34036.766   -34361.412   -34361.412    313.98623    313.98623    160755.05    160755.05    92.350444    92.350444 
Loop time of 11.4884 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.521 ns/day, 3.191 hours/ns, 87.044 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.145     | 11.145     | 11.145     |   0.0 | 97.01
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039619   | 0.039619   | 0.039619   |   0.0 |  0.34
Output  | 4.61e-05   | 4.61e-05   | 4.61e-05   |   0.0 |  0.00
Modify  | 0.27467    | 0.27467    | 0.27467    |   0.0 |  2.39
Other   |            | 0.02923    |            |       |  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:      275028.0 ave      275028 max      275028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275028
Ave neighs/atom = 34.378500
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   -34036.766   -34036.766   -34361.412   -34361.412    313.98623    313.98623    160755.05    160755.05    92.350444    92.350444 
    4000   -34039.326   -34039.326   -34363.101   -34363.101     313.1424     313.1424    160769.77    160769.77    46.812889    46.812889 
Loop time of 11.6303 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.429 ns/day, 3.231 hours/ns, 85.983 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.283     | 11.283     | 11.283     |   0.0 | 97.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039719   | 0.039719   | 0.039719   |   0.0 |  0.34
Output  | 5.48e-05   | 5.48e-05   | 5.48e-05   |   0.0 |  0.00
Modify  | 0.27747    | 0.27747    | 0.27747    |   0.0 |  2.39
Other   |            | 0.02957    |            |       |  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:      274992.0 ave      274992 max      274992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274992
Ave neighs/atom = 34.374000
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   -34039.326   -34039.326   -34363.101   -34363.101     313.1424     313.1424    160769.77    160769.77    46.812889    46.812889 
    5000   -34040.994   -34040.994   -34361.993   -34361.993    310.45866    310.45866    160753.49    160753.49    139.79436    139.79436 
Loop time of 11.3569 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.608 ns/day, 3.155 hours/ns, 88.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    | 11.015     | 11.015     | 11.015     |   0.0 | 96.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039134   | 0.039134   | 0.039134   |   0.0 |  0.34
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.27342    | 0.27342    | 0.27342    |   0.0 |  2.41
Other   |            | 0.02898    |            |       |  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:      275104.0 ave      275104 max      275104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275104
Ave neighs/atom = 34.388000
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 = 314.419421231079, Press = -706.703535728177
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   -34040.994   -34040.994   -34361.993   -34361.993    310.45866    310.45866    160753.49    160753.49    139.79436    139.79436 
    6000    -34035.24    -34035.24   -34372.769   -34372.769    326.44502    326.44502    160790.14    160790.14   -14.166042   -14.166042 
Loop time of 11.2345 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.691 ns/day, 3.121 hours/ns, 89.012 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.891     | 10.891     | 10.891     |   0.0 | 96.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038983   | 0.038983   | 0.038983   |   0.0 |  0.35
Output  | 3.61e-05   | 3.61e-05   | 3.61e-05   |   0.0 |  0.00
Modify  | 0.27629    | 0.27629    | 0.27629    |   0.0 |  2.46
Other   |            | 0.02861    |            |       |  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:      275106.0 ave      275106 max      275106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275106
Ave neighs/atom = 34.388250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.72905609744, Press = -46.503389635297
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    -34035.24    -34035.24   -34372.769   -34372.769    326.44502    326.44502    160790.14    160790.14   -14.166042   -14.166042 
    7000   -34045.492   -34045.492   -34374.966   -34374.966    318.65512    318.65512    160738.87    160738.87    284.39806    284.39806 
Loop time of 11.5611 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.473 ns/day, 3.211 hours/ns, 86.497 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.21      | 11.21      | 11.21      |   0.0 | 96.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04036    | 0.04036    | 0.04036    |   0.0 |  0.35
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.28107    | 0.28107    | 0.28107    |   0.0 |  2.43
Other   |            | 0.0295     |            |       |  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:      274632.0 ave      274632 max      274632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274632
Ave neighs/atom = 34.329000
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 = 313.062844802911, Press = -17.7880681512859
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   -34045.492   -34045.492   -34374.966   -34374.966    318.65512    318.65512    160738.87    160738.87    284.39806    284.39806 
    8000   -34037.234   -34037.234   -34360.471   -34360.471    312.62275    312.62275    160733.02    160733.02    301.67906    301.67906 
Loop time of 11.507 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.508 ns/day, 3.196 hours/ns, 86.904 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.157     | 11.157     | 11.157     |   0.0 | 96.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039417   | 0.039417   | 0.039417   |   0.0 |  0.34
Output  | 3.48e-05   | 3.48e-05   | 3.48e-05   |   0.0 |  0.00
Modify  | 0.28168    | 0.28168    | 0.28168    |   0.0 |  2.45
Other   |            | 0.0292     |            |       |  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:      274732.0 ave      274732 max      274732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274732
Ave neighs/atom = 34.341500
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 = 313.111221337606, Press = -12.1635287187573
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   -34037.234   -34037.234   -34360.471   -34360.471    312.62275    312.62275    160733.02    160733.02    301.67906    301.67906 
    9000   -34042.745   -34042.745   -34368.728   -34368.728    315.27796    315.27796    160720.27    160720.27    365.47635    365.47635 
Loop time of 11.6677 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.405 ns/day, 3.241 hours/ns, 85.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    | 11.315     | 11.315     | 11.315     |   0.0 | 96.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039679   | 0.039679   | 0.039679   |   0.0 |  0.34
Output  | 3.5e-05    | 3.5e-05    | 3.5e-05    |   0.0 |  0.00
Modify  | 0.28345    | 0.28345    | 0.28345    |   0.0 |  2.43
Other   |            | 0.02969    |            |       |  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:      275170.0 ave      275170 max      275170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275170
Ave neighs/atom = 34.396250
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 = 313.066749237869, Press = -11.2744221042141
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   -34042.745   -34042.745   -34368.728   -34368.728    315.27796    315.27796    160720.27    160720.27    365.47635    365.47635 
   10000   -34037.415   -34037.415   -34370.514   -34370.514    322.16129    322.16129    160748.64    160748.64    229.41943    229.41943 
Loop time of 11.585 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.458 ns/day, 3.218 hours/ns, 86.319 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.231     | 11.231     | 11.231     |   0.0 | 96.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040158   | 0.040158   | 0.040158   |   0.0 |  0.35
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.28371    | 0.28371    | 0.28371    |   0.0 |  2.45
Other   |            | 0.02975    |            |       |  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:      275044.0 ave      275044 max      275044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275044
Ave neighs/atom = 34.380500
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 = 313.1269761911, Press = -9.26340660573767
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   -34037.415   -34037.415   -34370.514   -34370.514    322.16129    322.16129    160748.64    160748.64    229.41943    229.41943 
   11000   -34037.246   -34037.246   -34356.668   -34356.668     308.9326     308.9326    160773.82    160773.82    90.295556    90.295556 
Loop time of 11.3928 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.584 ns/day, 3.165 hours/ns, 87.774 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.045     | 11.045     | 11.045     |   0.0 | 96.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039246   | 0.039246   | 0.039246   |   0.0 |  0.34
Output  | 4.42e-05   | 4.42e-05   | 4.42e-05   |   0.0 |  0.00
Modify  | 0.27906    | 0.27906    | 0.27906    |   0.0 |  2.45
Other   |            | 0.02925    |            |       |  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:      274892.0 ave      274892 max      274892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274892
Ave neighs/atom = 34.361500
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 = 313.008737329544, Press = -10.8578484286186
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   -34037.246   -34037.246   -34356.668   -34356.668     308.9326     308.9326    160773.82    160773.82    90.295556    90.295556 
   12000   -34040.987   -34040.987   -34363.879   -34363.879    312.28859    312.28859    160790.68    160790.68   -104.61876   -104.61876 
Loop time of 11.8126 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.314 ns/day, 3.281 hours/ns, 84.655 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.457     | 11.457     | 11.457     |   0.0 | 96.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040103   | 0.040103   | 0.040103   |   0.0 |  0.34
Output  | 4.42e-05   | 4.42e-05   | 4.42e-05   |   0.0 |  0.00
Modify  | 0.28606    | 0.28606    | 0.28606    |   0.0 |  2.42
Other   |            | 0.02987    |            |       |  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:      275346.0 ave      275346 max      275346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275346
Ave neighs/atom = 34.418250
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 = 313.22691300868, Press = -8.18518424595169
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   -34040.987   -34040.987   -34363.879   -34363.879    312.28859    312.28859    160790.68    160790.68   -104.61876   -104.61876 
   13000   -34038.284   -34038.284   -34362.638   -34362.638    313.70364    313.70364    160834.94    160834.94   -406.91513   -406.91513 
Loop time of 11.4984 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.514 ns/day, 3.194 hours/ns, 86.968 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.146     | 11.146     | 11.146     |   0.0 | 96.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039611   | 0.039611   | 0.039611   |   0.0 |  0.34
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.2831     | 0.2831     | 0.2831     |   0.0 |  2.46
Other   |            | 0.02964    |            |       |  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:      274958.0 ave      274958 max      274958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274958
Ave neighs/atom = 34.369750
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 = 313.206293954414, Press = -6.03453397982647
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   -34038.284   -34038.284   -34362.638   -34362.638    313.70364    313.70364    160834.94    160834.94   -406.91513   -406.91513 
   14000   -34033.209   -34033.209   -34353.444   -34353.444    309.71922    309.71922    160772.51    160772.51    47.522302    47.522302 
Loop time of 11.3511 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.612 ns/day, 3.153 hours/ns, 88.097 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.007     | 11.007     | 11.007     |   0.0 | 96.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038662   | 0.038662   | 0.038662   |   0.0 |  0.34
Output  | 3.59e-05   | 3.59e-05   | 3.59e-05   |   0.0 |  0.00
Modify  | 0.27691    | 0.27691    | 0.27691    |   0.0 |  2.44
Other   |            | 0.02851    |            |       |  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:      274958.0 ave      274958 max      274958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274958
Ave neighs/atom = 34.369750
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 = 313.195885195764, Press = -4.70209517192049
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   -34033.209   -34033.209   -34353.444   -34353.444    309.71922    309.71922    160772.51    160772.51    47.522302    47.522302 
   15000   -34043.159   -34043.159   -34360.373   -34360.373    306.79749    306.79749    160816.09    160816.09   -274.04438   -274.04438 
Loop time of 11.3531 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.610 ns/day, 3.154 hours/ns, 88.082 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.01      | 11.01      | 11.01      |   0.0 | 96.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038583   | 0.038583   | 0.038583   |   0.0 |  0.34
Output  | 4.38e-05   | 4.38e-05   | 4.38e-05   |   0.0 |  0.00
Modify  | 0.27633    | 0.27633    | 0.27633    |   0.0 |  2.43
Other   |            | 0.02848    |            |       |  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:      275248.0 ave      275248 max      275248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275248
Ave neighs/atom = 34.406000
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 = 313.316586583784, Press = -3.4308160350813
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   -34043.159   -34043.159   -34360.373   -34360.373    306.79749    306.79749    160816.09    160816.09   -274.04438   -274.04438 
   16000   -34035.118   -34035.118   -34364.755   -34364.755    318.81224    318.81224    160796.98    160796.98    -63.86413    -63.86413 
Loop time of 11.027 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.835 ns/day, 3.063 hours/ns, 90.686 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.69      | 10.69      | 10.69      |   0.0 | 96.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038049   | 0.038049   | 0.038049   |   0.0 |  0.35
Output  | 3.51e-05   | 3.51e-05   | 3.51e-05   |   0.0 |  0.00
Modify  | 0.2708     | 0.2708     | 0.2708     |   0.0 |  2.46
Other   |            | 0.0277     |            |       |  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:      275084.0 ave      275084 max      275084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275084
Ave neighs/atom = 34.385500
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 = 313.364592311614, Press = -2.43761733147845
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   -34035.118   -34035.118   -34364.755   -34364.755    318.81224    318.81224    160796.98    160796.98    -63.86413    -63.86413 
   17000   -34044.438   -34044.438   -34364.387   -34364.387    309.44317    309.44317    160806.86    160806.86   -187.65052   -187.65052 
Loop time of 10.794 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.004 ns/day, 2.998 hours/ns, 92.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    | 10.462     | 10.462     | 10.462     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037337   | 0.037337   | 0.037337   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.26749    | 0.26749    | 0.26749    |   0.0 |  2.48
Other   |            | 0.0272     |            |       |  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:      274930.0 ave      274930 max      274930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274930
Ave neighs/atom = 34.366250
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 = 313.341087532246, Press = -2.02235879323897
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   -34044.438   -34044.438   -34364.387   -34364.387    309.44317    309.44317    160806.86    160806.86   -187.65052   -187.65052 
   18000   -34035.738   -34035.738   -34366.731   -34366.731     320.1248     320.1248    160843.41    160843.41   -328.73047   -328.73047 
Loop time of 11.1404 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.756 ns/day, 3.095 hours/ns, 89.763 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.8       | 10.8       | 10.8       |   0.0 | 96.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038448   | 0.038448   | 0.038448   |   0.0 |  0.35
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.27406    | 0.27406    | 0.27406    |   0.0 |  2.46
Other   |            | 0.02818    |            |       |  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:      274986.0 ave      274986 max      274986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274986
Ave neighs/atom = 34.373250
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 = 313.227360278703, Press = -1.11151850033636
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   -34035.738   -34035.738   -34366.731   -34366.731     320.1248     320.1248    160843.41    160843.41   -328.73047   -328.73047 
   19000   -34033.294   -34033.294   -34362.825   -34362.825    318.71035    318.71035    160848.48    160848.48    -341.2856    -341.2856 
Loop time of 10.8445 on 1 procs for 1000 steps with 8000 atoms

Performance: 7.967 ns/day, 3.012 hours/ns, 92.212 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.512     | 10.512     | 10.512     |   0.0 | 96.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038046   | 0.038046   | 0.038046   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.26771    | 0.26771    | 0.26771    |   0.0 |  2.47
Other   |            | 0.02719    |            |       |  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:      274896.0 ave      274896 max      274896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274896
Ave neighs/atom = 34.362000
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 = 313.233352982745, Press = -0.5402208688619
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   -34033.294   -34033.294   -34362.825   -34362.825    318.71035    318.71035    160848.48    160848.48    -341.2856    -341.2856 
   20000   -34039.651   -34039.651   -34361.529   -34361.529    311.30826    311.30826    160781.72    160781.72    1.4483617    1.4483617 
Loop time of 10.5771 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.169 ns/day, 2.938 hours/ns, 94.544 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.252     | 10.252     | 10.252     |   0.0 | 96.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036449   | 0.036449   | 0.036449   |   0.0 |  0.34
Output  | 4.38e-05   | 4.38e-05   | 4.38e-05   |   0.0 |  0.00
Modify  | 0.26247    | 0.26247    | 0.26247    |   0.0 |  2.48
Other   |            | 0.02625    |            |       |  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:      274894.0 ave      274894 max      274894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274894
Ave neighs/atom = 34.361750
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 = 313.246348022071, Press = -1.46398936455419
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   -34039.651   -34039.651   -34361.529   -34361.529    311.30826    311.30826    160781.72    160781.72    1.4483617    1.4483617 
   21000   -34036.427   -34036.427   -34361.323   -34361.323    314.22674    314.22674     160768.5     160768.5    107.97837    107.97837 
Loop time of 10.6869 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.085 ns/day, 2.969 hours/ns, 93.572 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.36      | 10.36      | 10.36      |   0.0 | 96.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036564   | 0.036564   | 0.036564   |   0.0 |  0.34
Output  | 3.57e-05   | 3.57e-05   | 3.57e-05   |   0.0 |  0.00
Modify  | 0.26375    | 0.26375    | 0.26375    |   0.0 |  2.47
Other   |            | 0.02648    |            |       |  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:      275030.0 ave      275030 max      275030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275030
Ave neighs/atom = 34.378750
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 = 313.369307475177, Press = -2.15034939531347
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   -34036.427   -34036.427   -34361.323   -34361.323    314.22674    314.22674     160768.5     160768.5    107.97837    107.97837 
   22000   -34042.743   -34042.743    -34367.13    -34367.13    313.73554    313.73554    160779.82    160779.82    40.782901    40.782901 
Loop time of 10.6911 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.081 ns/day, 2.970 hours/ns, 93.535 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.363     | 10.363     | 10.363     |   0.0 | 96.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036832   | 0.036832   | 0.036832   |   0.0 |  0.34
Output  | 3.48e-05   | 3.48e-05   | 3.48e-05   |   0.0 |  0.00
Modify  | 0.26465    | 0.26465    | 0.26465    |   0.0 |  2.48
Other   |            | 0.02657    |            |       |  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:      274936.0 ave      274936 max      274936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274936
Ave neighs/atom = 34.367000
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 = 313.334720939038, Press = -1.4211717274381
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   -34042.743   -34042.743    -34367.13    -34367.13    313.73554    313.73554    160779.82    160779.82    40.782901    40.782901 
   23000   -34043.709   -34043.709   -34370.188   -34370.188    315.75861    315.75861    160681.41    160681.41    619.09624    619.09624 
Loop time of 10.4672 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.254 ns/day, 2.908 hours/ns, 95.536 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.144     | 10.144     | 10.144     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036416   | 0.036416   | 0.036416   |   0.0 |  0.35
Output  | 3.57e-05   | 3.57e-05   | 3.57e-05   |   0.0 |  0.00
Modify  | 0.2606     | 0.2606     | 0.2606     |   0.0 |  2.49
Other   |            | 0.026      |            |       |  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:      274908.0 ave      274908 max      274908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274908
Ave neighs/atom = 34.363500
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 = 313.308368747259, Press = -1.54788337566062
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   -34043.709   -34043.709   -34370.188   -34370.188    315.75861    315.75861    160681.41    160681.41    619.09624    619.09624 
   24000   -34040.608   -34040.608    -34359.65    -34359.65    308.56586    308.56586    160688.93    160688.93    548.09587    548.09587 
Loop time of 10.5659 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.177 ns/day, 2.935 hours/ns, 94.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    | 10.241     | 10.241     | 10.241     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036497   | 0.036497   | 0.036497   |   0.0 |  0.35
Output  | 4.46e-05   | 4.46e-05   | 4.46e-05   |   0.0 |  0.00
Modify  | 0.26243    | 0.26243    | 0.26243    |   0.0 |  2.48
Other   |            | 0.02615    |            |       |  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:      274926.0 ave      274926 max      274926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274926
Ave neighs/atom = 34.365750
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 = 313.214401744624, Press = -1.27843673422645
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   -34040.608   -34040.608    -34359.65    -34359.65    308.56586    308.56586    160688.93    160688.93    548.09587    548.09587 
   25000    -34033.92    -34033.92   -34360.059   -34360.059     315.4294     315.4294    160616.72    160616.72    1029.3326    1029.3326 
Loop time of 10.7474 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.039 ns/day, 2.985 hours/ns, 93.046 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.419     | 10.419     | 10.419     |   0.0 | 96.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036973   | 0.036973   | 0.036973   |   0.0 |  0.34
Output  | 3.53e-05   | 3.53e-05   | 3.53e-05   |   0.0 |  0.00
Modify  | 0.26522    | 0.26522    | 0.26522    |   0.0 |  2.47
Other   |            | 0.02656    |            |       |  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:      275206.0 ave      275206 max      275206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275206
Ave neighs/atom = 34.400750
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 = 313.236672946571, Press = -1.20513026783172
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    -34033.92    -34033.92   -34360.059   -34360.059     315.4294     315.4294    160616.72    160616.72    1029.3326    1029.3326 
   26000   -34041.603   -34041.603    -34370.76    -34370.76    318.34824    318.34824    160611.16    160611.16    1117.2396    1117.2396 
Loop time of 10.5427 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.195 ns/day, 2.929 hours/ns, 94.852 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.219     | 10.219     | 10.219     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036273   | 0.036273   | 0.036273   |   0.0 |  0.34
Output  | 5.16e-05   | 5.16e-05   | 5.16e-05   |   0.0 |  0.00
Modify  | 0.26197    | 0.26197    | 0.26197    |   0.0 |  2.48
Other   |            | 0.02591    |            |       |  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:      275386.0 ave      275386 max      275386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275386
Ave neighs/atom = 34.423250
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 = 313.264609655095, Press = -1.49681858135292
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   -34041.603   -34041.603    -34370.76    -34370.76    318.34824    318.34824    160611.16    160611.16    1117.2396    1117.2396 
   27000    -34040.84    -34040.84   -34358.691   -34358.691    307.41299    307.41299    160724.66    160724.66    340.67165    340.67165 
Loop time of 10.6308 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.127 ns/day, 2.953 hours/ns, 94.066 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.304     | 10.304     | 10.304     |   0.0 | 96.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036552   | 0.036552   | 0.036552   |   0.0 |  0.34
Output  | 4.43e-05   | 4.43e-05   | 4.43e-05   |   0.0 |  0.00
Modify  | 0.26349    | 0.26349    | 0.26349    |   0.0 |  2.48
Other   |            | 0.02645    |            |       |  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:      274854.0 ave      274854 max      274854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274854
Ave neighs/atom = 34.356750
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 = 313.284291646688, Press = -1.80340251505586
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    -34040.84    -34040.84   -34358.691   -34358.691    307.41299    307.41299    160724.66    160724.66    340.67165    340.67165 
   28000   -34032.498   -34032.498   -34354.497   -34354.497    311.42545    311.42545    160731.96    160731.96    331.46315    331.46315 
Loop time of 10.5499 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.190 ns/day, 2.931 hours/ns, 94.787 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.225     | 10.225     | 10.225     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036521   | 0.036521   | 0.036521   |   0.0 |  0.35
Output  | 3.53e-05   | 3.53e-05   | 3.53e-05   |   0.0 |  0.00
Modify  | 0.26211    | 0.26211    | 0.26211    |   0.0 |  2.48
Other   |            | 0.02611    |            |       |  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:      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 = 313.341098310682, Press = -1.84783960779181
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   -34032.498   -34032.498   -34354.497   -34354.497    311.42545    311.42545    160731.96    160731.96    331.46315    331.46315 
   29000   -34038.005   -34038.005   -34359.887   -34359.887    311.31253    311.31253    160721.71    160721.71    334.22706    334.22706 
Loop time of 10.3918 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.314 ns/day, 2.887 hours/ns, 96.230 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.071     | 10.071     | 10.071     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036291   | 0.036291   | 0.036291   |   0.0 |  0.35
Output  | 3.52e-05   | 3.52e-05   | 3.52e-05   |   0.0 |  0.00
Modify  | 0.25889    | 0.25889    | 0.25889    |   0.0 |  2.49
Other   |            | 0.02589    |            |       |  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:      275304.0 ave      275304 max      275304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275304
Ave neighs/atom = 34.413000
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 = 313.308862805509, Press = -2.03670780258526
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   -34038.005   -34038.005   -34359.887   -34359.887    311.31253    311.31253    160721.71    160721.71    334.22706    334.22706 
   30000   -34046.068   -34046.068   -34369.385   -34369.385    312.70014    312.70014    160661.95    160661.95    749.59924    749.59924 
Loop time of 10.4431 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.273 ns/day, 2.901 hours/ns, 95.757 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.122     | 10.122     | 10.122     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036055   | 0.036055   | 0.036055   |   0.0 |  0.35
Output  | 3.52e-05   | 3.52e-05   | 3.52e-05   |   0.0 |  0.00
Modify  | 0.25981    | 0.25981    | 0.25981    |   0.0 |  2.49
Other   |            | 0.02563    |            |       |  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:      275208.0 ave      275208 max      275208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275208
Ave neighs/atom = 34.401000
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 = 313.26979341305, Press = -2.70302219948295
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   -34046.068   -34046.068   -34369.385   -34369.385    312.70014    312.70014    160661.95    160661.95    749.59924    749.59924 
   31000   -34036.976   -34036.976   -34359.235   -34359.235    311.67661    311.67661    160759.53    160759.53     75.00454     75.00454 
Loop time of 10.0836 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.568 ns/day, 2.801 hours/ns, 99.171 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.7709     | 9.7709     | 9.7709     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036011   | 0.036011   | 0.036011   |   0.0 |  0.36
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.25245    | 0.25245    | 0.25245    |   0.0 |  2.50
Other   |            | 0.02423    |            |       |  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:      274918.0 ave      274918 max      274918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274918
Ave neighs/atom = 34.364750
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 = 313.239451454742, Press = -2.32179492152252
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   -34036.976   -34036.976   -34359.235   -34359.235    311.67661    311.67661    160759.53    160759.53     75.00454     75.00454 
   32000   -34047.369   -34047.369   -34361.302   -34361.302    303.62446    303.62446     160762.6     160762.6    14.347599    14.347599 
Loop time of 10.2654 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.417 ns/day, 2.851 hours/ns, 97.415 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.9491     | 9.9491     | 9.9491     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035614   | 0.035614   | 0.035614   |   0.0 |  0.35
Output  | 3.6e-05    | 3.6e-05    | 3.6e-05    |   0.0 |  0.00
Modify  | 0.25597    | 0.25597    | 0.25597    |   0.0 |  2.49
Other   |            | 0.02465    |            |       |  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:      275356.0 ave      275356 max      275356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275356
Ave neighs/atom = 34.419500
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 = 313.191104128068, Press = -1.78637978276653
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   -34047.369   -34047.369   -34361.302   -34361.302    303.62446    303.62446     160762.6     160762.6    14.347599    14.347599 
   33000   -34036.919   -34036.919   -34363.386   -34363.386    315.74687    315.74687     160793.4     160793.4   -24.266595   -24.266595 
Loop time of 9.93178 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.699 ns/day, 2.759 hours/ns, 100.687 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.6228     | 9.6228     | 9.6228     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034929   | 0.034929   | 0.034929   |   0.0 |  0.35
Output  | 3.52e-05   | 3.52e-05   | 3.52e-05   |   0.0 |  0.00
Modify  | 0.24999    | 0.24999    | 0.24999    |   0.0 |  2.52
Other   |            | 0.02399    |            |       |  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:      275130.0 ave      275130 max      275130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275130
Ave neighs/atom = 34.391250
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 = 313.166189986604, Press = -1.4346480745604
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   -34036.919   -34036.919   -34363.386   -34363.386    315.74687    315.74687     160793.4     160793.4   -24.266595   -24.266595 
   34000   -34041.112   -34041.112   -34363.957   -34363.957    312.24406    312.24406    160859.72    160859.72   -515.37302   -515.37302 
Loop time of 10.1275 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.531 ns/day, 2.813 hours/ns, 98.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.8123     | 9.8123     | 9.8123     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03545    | 0.03545    | 0.03545    |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.25522    | 0.25522    | 0.25522    |   0.0 |  2.52
Other   |            | 0.02454    |            |       |  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:      274976.0 ave      274976 max      274976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274976
Ave neighs/atom = 34.372000
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 = 313.139980344294, Press = -1.56965317132019
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   -34041.112   -34041.112   -34363.957   -34363.957    312.24406    312.24406    160859.72    160859.72   -515.37302   -515.37302 
   35000   -34033.811   -34033.811   -34361.536   -34361.536    316.96423    316.96423     160901.2     160901.2   -638.25907   -638.25907 
Loop time of 10.0957 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.558 ns/day, 2.804 hours/ns, 99.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.7838     | 9.7838     | 9.7838     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035258   | 0.035258   | 0.035258   |   0.0 |  0.35
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.25251    | 0.25251    | 0.25251    |   0.0 |  2.50
Other   |            | 0.02416    |            |       |  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:      274964.0 ave      274964 max      274964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274964
Ave neighs/atom = 34.370500
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 = 313.149218169664, Press = -1.49218603175117
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   -34033.811   -34033.811   -34361.536   -34361.536    316.96423    316.96423     160901.2     160901.2   -638.25907   -638.25907 
   36000   -34042.398   -34042.398   -34360.857   -34360.857    308.00139    308.00139    160972.01    160972.01   -1245.7087   -1245.7087 
Loop time of 10.2204 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.454 ns/day, 2.839 hours/ns, 97.843 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.906      | 9.906      | 9.906      |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035299   | 0.035299   | 0.035299   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.25461    | 0.25461    | 0.25461    |   0.0 |  2.49
Other   |            | 0.02447    |            |       |  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:      274800.0 ave      274800 max      274800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274800
Ave neighs/atom = 34.350000
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 = 313.170357715772, Press = -1.47842196478922
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   -34042.398   -34042.398   -34360.857   -34360.857    308.00139    308.00139    160972.01    160972.01   -1245.7087   -1245.7087 
   37000   -34032.526   -34032.526   -34360.314   -34360.314    317.02378    317.02378    160901.18    160901.18   -680.45747   -680.45747 
Loop time of 10.0554 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.592 ns/day, 2.793 hours/ns, 99.449 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.7441     | 9.7441     | 9.7441     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035534   | 0.035534   | 0.035534   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.25157    | 0.25157    | 0.25157    |   0.0 |  2.50
Other   |            | 0.0241     |            |       |  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:      274924.0 ave      274924 max      274924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274924
Ave neighs/atom = 34.365500
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 = 313.205635250947, Press = -1.02810374054508
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   -34032.526   -34032.526   -34360.314   -34360.314    317.02378    317.02378    160901.18    160901.18   -680.45747   -680.45747 
   38000   -34042.478   -34042.478   -34366.069   -34366.069    312.96439    312.96439    160794.39    160794.39    -63.21671    -63.21671 
Loop time of 10.0661 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.583 ns/day, 2.796 hours/ns, 99.343 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.7546     | 9.7546     | 9.7546     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035124   | 0.035124   | 0.035124   |   0.0 |  0.35
Output  | 3.53e-05   | 3.53e-05   | 3.53e-05   |   0.0 |  0.00
Modify  | 0.25212    | 0.25212    | 0.25212    |   0.0 |  2.50
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:      274828.0 ave      274828 max      274828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274828
Ave neighs/atom = 34.353500
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 = 313.216259111715, Press = -0.932067006036467
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   -34042.478   -34042.478   -34366.069   -34366.069    312.96439    312.96439    160794.39    160794.39    -63.21671    -63.21671 
   39000   -34045.936   -34045.936   -34364.437   -34364.437    308.04252    308.04252    160843.42    160843.42   -455.75789   -455.75789 
Loop time of 10.293 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.394 ns/day, 2.859 hours/ns, 97.153 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.9761     | 9.9761     | 9.9761     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035633   | 0.035633   | 0.035633   |   0.0 |  0.35
Output  | 3.59e-05   | 3.59e-05   | 3.59e-05   |   0.0 |  0.00
Modify  | 0.25651    | 0.25651    | 0.25651    |   0.0 |  2.49
Other   |            | 0.02477    |            |       |  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:      274874.0 ave      274874 max      274874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274874
Ave neighs/atom = 34.359250
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 = 313.20512149253, Press = -1.02941601937703
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   -34045.936   -34045.936   -34364.437   -34364.437    308.04252    308.04252    160843.42    160843.42   -455.75789   -455.75789 
   40000   -34038.741   -34038.741   -34366.529   -34366.529    317.02453    317.02453     160861.1     160861.1   -453.04905   -453.04905 
Loop time of 10.0699 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.580 ns/day, 2.797 hours/ns, 99.306 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.7573     | 9.7573     | 9.7573     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035344   | 0.035344   | 0.035344   |   0.0 |  0.35
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.2529     | 0.2529     | 0.2529     |   0.0 |  2.51
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:      274870.0 ave      274870 max      274870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274870
Ave neighs/atom = 34.358750
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 = 313.164291710858, Press = -0.748545692378581
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   -34038.741   -34038.741   -34366.529   -34366.529    317.02453    317.02453     160861.1     160861.1   -453.04905   -453.04905 
   41000   -34040.773   -34040.773   -34364.312   -34364.312    312.91531    312.91531    160905.81    160905.81   -755.73483   -755.73483 
Loop time of 10.1707 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.495 ns/day, 2.825 hours/ns, 98.322 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.856      | 9.856      | 9.856      |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035639   | 0.035639   | 0.035639   |   0.0 |  0.35
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.25446    | 0.25446    | 0.25446    |   0.0 |  2.50
Other   |            | 0.02455    |            |       |  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:      274814.0 ave      274814 max      274814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274814
Ave neighs/atom = 34.351750
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 = 313.14447622137, Press = -0.719657465440221
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   -34040.773   -34040.773   -34364.312   -34364.312    312.91531    312.91531    160905.81    160905.81   -755.73483   -755.73483 
   42000   -34038.928   -34038.928   -34361.745   -34361.745    312.21648    312.21648    160855.32    160855.32   -497.32715   -497.32715 
Loop time of 10.137 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.523 ns/day, 2.816 hours/ns, 98.648 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.8247     | 9.8247     | 9.8247     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03525    | 0.03525    | 0.03525    |   0.0 |  0.35
Output  | 3.48e-05   | 3.48e-05   | 3.48e-05   |   0.0 |  0.00
Modify  | 0.25289    | 0.25289    | 0.25289    |   0.0 |  2.49
Other   |            | 0.02418    |            |       |  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:      274906.0 ave      274906 max      274906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274906
Ave neighs/atom = 34.363250
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 = 313.176182073478, Press = -0.283031654192141
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   -34038.928   -34038.928   -34361.745   -34361.745    312.21648    312.21648    160855.32    160855.32   -497.32715   -497.32715 
   43000   -34037.524   -34037.524   -34361.386   -34361.386    313.22802    313.22802       160828       160828   -293.30815   -293.30815 
Loop time of 10.0773 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.574 ns/day, 2.799 hours/ns, 99.232 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.7656     | 9.7656     | 9.7656     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035066   | 0.035066   | 0.035066   |   0.0 |  0.35
Output  | 3.61e-05   | 3.61e-05   | 3.61e-05   |   0.0 |  0.00
Modify  | 0.25234    | 0.25234    | 0.25234    |   0.0 |  2.50
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:      275032.0 ave      275032 max      275032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275032
Ave neighs/atom = 34.379000
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 = 313.152575077329, Press = -0.543198189481023
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   -34037.524   -34037.524   -34361.386   -34361.386    313.22802    313.22802       160828       160828   -293.30815   -293.30815 
   44000   -34043.817   -34043.817   -34369.252   -34369.252    314.74852    314.74852    160743.26    160743.26    201.04985    201.04985 
Loop time of 10.1818 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.486 ns/day, 2.828 hours/ns, 98.214 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.8679     | 9.8679     | 9.8679     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035352   | 0.035352   | 0.035352   |   0.0 |  0.35
Output  | 3.52e-05   | 3.52e-05   | 3.52e-05   |   0.0 |  0.00
Modify  | 0.25401    | 0.25401    | 0.25401    |   0.0 |  2.49
Other   |            | 0.02449    |            |       |  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:      274908.0 ave      274908 max      274908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274908
Ave neighs/atom = 34.363500
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 = 313.123056576973, Press = -0.644352231249838
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   -34043.817   -34043.817   -34369.252   -34369.252    314.74852    314.74852    160743.26    160743.26    201.04985    201.04985 
   45000   -34033.293   -34033.293   -34366.198   -34366.198    321.97383    321.97383    160742.84    160742.84    262.93223    262.93223 
Loop time of 10.2569 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.424 ns/day, 2.849 hours/ns, 97.496 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.9416     | 9.9416     | 9.9416     |   0.0 | 96.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035784   | 0.035784   | 0.035784   |   0.0 |  0.35
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.25499    | 0.25499    | 0.25499    |   0.0 |  2.49
Other   |            | 0.02449    |            |       |  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:      274828.0 ave      274828 max      274828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274828
Ave neighs/atom = 34.353500
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 = 313.134188128221, Press = -0.652800847010872
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   -34033.293   -34033.293   -34366.198   -34366.198    321.97383    321.97383    160742.84    160742.84    262.93223    262.93223 
   46000   -34041.623   -34041.623   -34363.239   -34363.239    311.05524    311.05524    160775.13    160775.13    20.952871    20.952871 
Loop time of 10.1848 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.483 ns/day, 2.829 hours/ns, 98.186 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.8708     | 9.8708     | 9.8708     |   0.0 | 96.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035366   | 0.035366   | 0.035366   |   0.0 |  0.35
Output  | 3.53e-05   | 3.53e-05   | 3.53e-05   |   0.0 |  0.00
Modify  | 0.25425    | 0.25425    | 0.25425    |   0.0 |  2.50
Other   |            | 0.02436    |            |       |  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:      275158.0 ave      275158 max      275158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275158
Ave neighs/atom = 34.394750
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 = 313.165212141144, Press = -0.706183417326815
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   -34041.623   -34041.623   -34363.239   -34363.239    311.05524    311.05524    160775.13    160775.13    20.952871    20.952871 
   47000   -34034.054   -34034.054   -34362.401   -34362.401    317.56458    317.56458    160711.37    160711.37     461.6064     461.6064 
Loop time of 10.0153 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.627 ns/day, 2.782 hours/ns, 99.847 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.7061     | 9.7061     | 9.7061     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035002   | 0.035002   | 0.035002   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.25099    | 0.25099    | 0.25099    |   0.0 |  2.51
Other   |            | 0.02325    |            |       |  0.23

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:      274990.0 ave      274990 max      274990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274990
Ave neighs/atom = 34.373750
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 = 313.181770210293, Press = -0.688597337955199
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 
   47000   -34034.054   -34034.054   -34362.401   -34362.401    317.56458    317.56458    160711.37    160711.37     461.6064     461.6064 
   48000   -34036.562   -34036.562   -34360.807   -34360.807    313.59777    313.59777     160690.6     160690.6    552.91447    552.91447 
Loop time of 9.8375 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.783 ns/day, 2.733 hours/ns, 101.652 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.5319     | 9.5319     | 9.5319     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034669   | 0.034669   | 0.034669   |   0.0 |  0.35
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.24832    | 0.24832    | 0.24832    |   0.0 |  2.52
Other   |            | 0.02254    |            |       |  0.23

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:      275050.0 ave      275050 max      275050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275050
Ave neighs/atom = 34.381250
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 = 313.184378918333, Press = -0.738968448400881
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 
   48000   -34036.562   -34036.562   -34360.807   -34360.807    313.59777    313.59777     160690.6     160690.6    552.91447    552.91447 
   49000   -34040.568   -34040.568   -34362.525   -34362.525     311.3847     311.3847    160639.72    160639.72    870.96529    870.96529 
Loop time of 9.80556 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.811 ns/day, 2.724 hours/ns, 101.983 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.501      | 9.501      | 9.501      |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034567   | 0.034567   | 0.034567   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.24757    | 0.24757    | 0.24757    |   0.0 |  2.52
Other   |            | 0.02237    |            |       |  0.23

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:      275208.0 ave      275208 max      275208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275208
Ave neighs/atom = 34.401000
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 = 313.153262845855, Press = -0.784775927099227
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 
   49000   -34040.568   -34040.568   -34362.525   -34362.525     311.3847     311.3847    160639.72    160639.72    870.96529    870.96529 
   50000    -34047.47    -34047.47   -34362.106   -34362.106    304.30387    304.30387    160642.66    160642.66    777.12554    777.12554 
Loop time of 9.78602 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.829 ns/day, 2.718 hours/ns, 102.187 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.481      | 9.481      | 9.481      |   0.0 | 96.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034599   | 0.034599   | 0.034599   |   0.0 |  0.35
Output  | 5.69e-05   | 5.69e-05   | 5.69e-05   |   0.0 |  0.00
Modify  | 0.24793    | 0.24793    | 0.24793    |   0.0 |  2.53
Other   |            | 0.02242    |            |       |  0.23

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:      275204.0 ave      275204 max      275204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275204
Ave neighs/atom = 34.400500
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 = 313.142868492215, Press = -0.814556547658082
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 
   50000    -34047.47    -34047.47   -34362.106   -34362.106    304.30387    304.30387    160642.66    160642.66    777.12554    777.12554 
   51000   -34035.037   -34035.037   -34360.339   -34360.339    314.61936    314.61936    160655.74    160655.74    804.35976    804.35976 
Loop time of 9.81864 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.800 ns/day, 2.727 hours/ns, 101.847 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.5137     | 9.5137     | 9.5137     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034492   | 0.034492   | 0.034492   |   0.0 |  0.35
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.2478     | 0.2478     | 0.2478     |   0.0 |  2.52
Other   |            | 0.02257    |            |       |  0.23

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:      275242.0 ave      275242 max      275242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275242
Ave neighs/atom = 34.405250
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 = 313.121747747128, Press = -0.88347391209629
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 
   51000   -34035.037   -34035.037   -34360.339   -34360.339    314.61936    314.61936    160655.74    160655.74    804.35976    804.35976 
   52000   -34044.199   -34044.199   -34368.339   -34368.339    313.49595    313.49595    160745.37    160745.37    180.38273    180.38273 
Loop time of 9.82887 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.790 ns/day, 2.730 hours/ns, 101.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5238     | 9.5238     | 9.5238     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034685   | 0.034685   | 0.034685   |   0.0 |  0.35
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.24794    | 0.24794    | 0.24794    |   0.0 |  2.52
Other   |            | 0.02244    |            |       |  0.23

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:      275194.0 ave      275194 max      275194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275194
Ave neighs/atom = 34.399250
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 = 313.112967036985, Press = -0.858802084368382
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 
   52000   -34044.199   -34044.199   -34368.339   -34368.339    313.49595    313.49595    160745.37    160745.37    180.38273    180.38273 
   53000   -34042.202   -34042.202   -34363.101   -34363.101    310.36155    310.36155    160750.55    160750.55    178.82144    178.82144 
Loop time of 9.82583 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.793 ns/day, 2.729 hours/ns, 101.773 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.5202     | 9.5202     | 9.5202     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034697   | 0.034697   | 0.034697   |   0.0 |  0.35
Output  | 3.54e-05   | 3.54e-05   | 3.54e-05   |   0.0 |  0.00
Modify  | 0.24828    | 0.24828    | 0.24828    |   0.0 |  2.53
Other   |            | 0.02262    |            |       |  0.23

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:      274926.0 ave      274926 max      274926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274926
Ave neighs/atom = 34.365750
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 = 313.125700130893, Press = -0.790327810971324
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 
   53000   -34042.202   -34042.202   -34363.101   -34363.101    310.36155    310.36155    160750.55    160750.55    178.82144    178.82144 
   54000   -34039.443   -34039.443   -34364.717   -34364.717    314.59359    314.59359    160770.38    160770.38    39.077364    39.077364 
Loop time of 9.82984 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.790 ns/day, 2.731 hours/ns, 101.731 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.5234     | 9.5234     | 9.5234     |   0.0 | 96.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034608   | 0.034608   | 0.034608   |   0.0 |  0.35
Output  | 3.5e-05    | 3.5e-05    | 3.5e-05    |   0.0 |  0.00
Modify  | 0.24831    | 0.24831    | 0.24831    |   0.0 |  2.53
Other   |            | 0.02348    |            |       |  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:      275116.0 ave      275116 max      275116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275116
Ave neighs/atom = 34.389500
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 = 313.127687457444, Press = -0.75938475083554
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 
   54000   -34039.443   -34039.443   -34364.717   -34364.717    314.59359    314.59359    160770.38    160770.38    39.077364    39.077364 
   55000    -34048.38    -34048.38   -34366.625   -34366.625    307.79529    307.79529    160844.37    160844.37   -492.10761   -492.10761 
Loop time of 9.80971 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.808 ns/day, 2.725 hours/ns, 101.940 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.5046     | 9.5046     | 9.5046     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034758   | 0.034758   | 0.034758   |   0.0 |  0.35
Output  | 3.57e-05   | 3.57e-05   | 3.57e-05   |   0.0 |  0.00
Modify  | 0.24788    | 0.24788    | 0.24788    |   0.0 |  2.53
Other   |            | 0.02245    |            |       |  0.23

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:      275164.0 ave      275164 max      275164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275164
Ave neighs/atom = 34.395500
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 = 313.101627335475, Press = -1.0960758524552
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 
   55000    -34048.38    -34048.38   -34366.625   -34366.625    307.79529    307.79529    160844.37    160844.37   -492.10761   -492.10761 
   56000   -34041.128   -34041.128   -34362.488   -34362.488    310.80715    310.80715    160868.03    160868.03    -573.5167    -573.5167 
Loop time of 9.83247 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.787 ns/day, 2.731 hours/ns, 101.704 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.5279     | 9.5279     | 9.5279     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034557   | 0.034557   | 0.034557   |   0.0 |  0.35
Output  | 3.57e-05   | 3.57e-05   | 3.57e-05   |   0.0 |  0.00
Modify  | 0.24762    | 0.24762    | 0.24762    |   0.0 |  2.52
Other   |            | 0.02235    |            |       |  0.23

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:      274796.0 ave      274796 max      274796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274796
Ave neighs/atom = 34.349500
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 = 313.111275322291, Press = -1.11270532259162
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 
   56000   -34041.128   -34041.128   -34362.488   -34362.488    310.80715    310.80715    160868.03    160868.03    -573.5167    -573.5167 
   57000    -34038.89    -34038.89   -34363.909   -34363.909    314.34691    314.34691    160865.34    160865.34   -529.82057   -529.82057 
Loop time of 9.85982 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.763 ns/day, 2.739 hours/ns, 101.422 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.5545     | 9.5545     | 9.5545     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034661   | 0.034661   | 0.034661   |   0.0 |  0.35
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.248      | 0.248      | 0.248      |   0.0 |  2.52
Other   |            | 0.02258    |            |       |  0.23

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:      274872.0 ave      274872 max      274872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274872
Ave neighs/atom = 34.359000
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 = 313.128980631344, Press = -0.92045237631002
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 
   57000    -34038.89    -34038.89   -34363.909   -34363.909    314.34691    314.34691    160865.34    160865.34   -529.82057   -529.82057 
   58000   -34043.583   -34043.583   -34363.942   -34363.942    309.83891    309.83891    160848.22    160848.22   -475.74168   -475.74168 
Loop time of 9.83888 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.781 ns/day, 2.733 hours/ns, 101.638 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.5338     | 9.5338     | 9.5338     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034491   | 0.034491   | 0.034491   |   0.0 |  0.35
Output  | 3.46e-05   | 3.46e-05   | 3.46e-05   |   0.0 |  0.00
Modify  | 0.24812    | 0.24812    | 0.24812    |   0.0 |  2.52
Other   |            | 0.0224     |            |       |  0.23

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:      274790.0 ave      274790 max      274790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274790
Ave neighs/atom = 34.348750
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 = 313.135428038891, Press = -0.889148900773533
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 
   58000   -34043.583   -34043.583   -34363.942   -34363.942    309.83891    309.83891    160848.22    160848.22   -475.74168   -475.74168 
   59000   -34029.893   -34029.893    -34360.83    -34360.83    320.07063    320.07063    160856.42    160856.42   -459.31862   -459.31862 
Loop time of 9.84518 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.776 ns/day, 2.735 hours/ns, 101.573 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.5404     | 9.5404     | 9.5404     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034629   | 0.034629   | 0.034629   |   0.0 |  0.35
Output  | 3.56e-05   | 3.56e-05   | 3.56e-05   |   0.0 |  0.00
Modify  | 0.24768    | 0.24768    | 0.24768    |   0.0 |  2.52
Other   |            | 0.02243    |            |       |  0.23

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:      275006.0 ave      275006 max      275006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275006
Ave neighs/atom = 34.375750
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 = 313.146523601769, Press = -0.603174030992795
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 
   59000   -34029.893   -34029.893    -34360.83    -34360.83    320.07063    320.07063    160856.42    160856.42   -459.31862   -459.31862 
   60000   -34041.617   -34041.617   -34360.357   -34360.357    308.27358    308.27358    160826.17    160826.17   -359.38978   -359.38978 
Loop time of 9.85806 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.764 ns/day, 2.738 hours/ns, 101.440 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.5531     | 9.5531     | 9.5531     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034661   | 0.034661   | 0.034661   |   0.0 |  0.35
Output  | 3.6e-05    | 3.6e-05    | 3.6e-05    |   0.0 |  0.00
Modify  | 0.24769    | 0.24769    | 0.24769    |   0.0 |  2.51
Other   |            | 0.02254    |            |       |  0.23

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:      275044.0 ave      275044 max      275044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275044
Ave neighs/atom = 34.380500
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 = 313.173830591338, Press = -0.59084098885698
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 
   60000   -34041.617   -34041.617   -34360.357   -34360.357    308.27358    308.27358    160826.17    160826.17   -359.38978   -359.38978 
   61000    -34042.13    -34042.13   -34362.528   -34362.528    309.87793    309.87793    160892.77    160892.77   -757.28124   -757.28124 
Loop time of 9.82689 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.792 ns/day, 2.730 hours/ns, 101.762 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.5223     | 9.5223     | 9.5223     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034674   | 0.034674   | 0.034674   |   0.0 |  0.35
Output  | 5.74e-05   | 5.74e-05   | 5.74e-05   |   0.0 |  0.00
Modify  | 0.24741    | 0.24741    | 0.24741    |   0.0 |  2.52
Other   |            | 0.02244    |            |       |  0.23

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:      275230.0 ave      275230 max      275230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275230
Ave neighs/atom = 34.403750
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 = 313.185219927119, Press = -0.550483104397649
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 
   61000    -34042.13    -34042.13   -34362.528   -34362.528    309.87793    309.87793    160892.77    160892.77   -757.28124   -757.28124 
   62000   -34041.114   -34041.114   -34364.543   -34364.543    312.80857    312.80857    160925.53    160925.53   -957.96678   -957.96678 
Loop time of 9.81531 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.803 ns/day, 2.726 hours/ns, 101.882 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.5098     | 9.5098     | 9.5098     |   0.0 | 96.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034612   | 0.034612   | 0.034612   |   0.0 |  0.35
Output  | 3.58e-05   | 3.58e-05   | 3.58e-05   |   0.0 |  0.00
Modify  | 0.24843    | 0.24843    | 0.24843    |   0.0 |  2.53
Other   |            | 0.02239    |            |       |  0.23

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:      275050.0 ave      275050 max      275050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275050
Ave neighs/atom = 34.381250
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 = 313.154955902219, Press = -0.454183872041959
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 
   62000   -34041.114   -34041.114   -34364.543   -34364.543    312.80857    312.80857    160925.53    160925.53   -957.96678   -957.96678 
   63000   -34044.382   -34044.382   -34365.345   -34365.345    310.42384    310.42384    160899.85    160899.85   -778.87532   -778.87532 
Loop time of 9.86863 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.755 ns/day, 2.741 hours/ns, 101.331 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.5626     | 9.5626     | 9.5626     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034707   | 0.034707   | 0.034707   |   0.0 |  0.35
Output  | 3.53e-05   | 3.53e-05   | 3.53e-05   |   0.0 |  0.00
Modify  | 0.24868    | 0.24868    | 0.24868    |   0.0 |  2.52
Other   |            | 0.02256    |            |       |  0.23

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:      275050.0 ave      275050 max      275050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275050
Ave neighs/atom = 34.381250
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 = 313.151435367096, Press = -0.353245969269018
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 
   63000   -34044.382   -34044.382   -34365.345   -34365.345    310.42384    310.42384    160899.85    160899.85   -778.87532   -778.87532 
   64000   -34033.929   -34033.929   -34356.311   -34356.311     311.7958     311.7958    160817.41    160817.41   -284.85183   -284.85183 
Loop time of 9.86464 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.759 ns/day, 2.740 hours/ns, 101.372 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.5594     | 9.5594     | 9.5594     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034628   | 0.034628   | 0.034628   |   0.0 |  0.35
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.24802    | 0.24802    | 0.24802    |   0.0 |  2.51
Other   |            | 0.02251    |            |       |  0.23

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:      274870.0 ave      274870 max      274870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 274870
Ave neighs/atom = 34.358750
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 = 313.164682095257, Press = -0.497657926549294
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 
   64000   -34033.929   -34033.929   -34356.311   -34356.311     311.7958     311.7958    160817.41    160817.41   -284.85183   -284.85183 
   65000   -34039.537   -34039.537   -34364.244   -34364.244    314.04431    314.04431    160780.69    160780.69    -16.99509    -16.99509 
Loop time of 9.85482 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.767 ns/day, 2.737 hours/ns, 101.473 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.5492     | 9.5492     | 9.5492     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034789   | 0.034789   | 0.034789   |   0.0 |  0.35
Output  | 3.55e-05   | 3.55e-05   | 3.55e-05   |   0.0 |  0.00
Modify  | 0.2482     | 0.2482     | 0.2482     |   0.0 |  2.52
Other   |            | 0.02258    |            |       |  0.23

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:      275412.0 ave      275412 max      275412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275412
Ave neighs/atom = 34.426500
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 = 313.172894856612, Press = -0.514155590353842
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 
   65000   -34039.537   -34039.537   -34364.244   -34364.244    314.04431    314.04431    160780.69    160780.69    -16.99509    -16.99509 
   66000   -34043.499   -34043.499   -34362.451   -34362.451    308.47861    308.47861    160744.24    160744.24    142.94163    142.94163 
Loop time of 9.88317 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.742 ns/day, 2.745 hours/ns, 101.182 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.5772     | 9.5772     | 9.5772     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03473    | 0.03473    | 0.03473    |   0.0 |  0.35
Output  | 3.57e-05   | 3.57e-05   | 3.57e-05   |   0.0 |  0.00
Modify  | 0.2486     | 0.2486     | 0.2486     |   0.0 |  2.52
Other   |            | 0.02257    |            |       |  0.23

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:      275226.0 ave      275226 max      275226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275226
Ave neighs/atom = 34.403250
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 = 313.19593629143, Press = -0.383132579632486
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 
   66000   -34043.499   -34043.499   -34362.451   -34362.451    308.47861    308.47861    160744.24    160744.24    142.94163    142.94163 
   67000   -34034.465   -34034.465   -34363.062   -34363.062    317.80695    317.80695    160748.69    160748.69    267.27188    267.27188 
Loop time of 9.84136 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.779 ns/day, 2.734 hours/ns, 101.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.5368     | 9.5368     | 9.5368     |   0.0 | 96.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034621   | 0.034621   | 0.034621   |   0.0 |  0.35
Output  | 3.63e-05   | 3.63e-05   | 3.63e-05   |   0.0 |  0.00
Modify  | 0.24751    | 0.24751    | 0.24751    |   0.0 |  2.51
Other   |            | 0.02236    |            |       |  0.23

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:      275178.0 ave      275178 max      275178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 275178
Ave neighs/atom = 34.397250
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 = 313.200014454956, Press = -0.434301980168391
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 
   67000   -34034.465   -34034.465   -34363.062   -34363.062    317.80695    317.80695    160748.69    160748.69    267.27188    267.27188 
   68000    -34043.43    -34043.43   -34367.255   -34367.255    313.19161    313.19161    160674.45    160674.45    633.52929    633.52929 
Loop time of 9.82469 on 1 procs for 1000 steps with 8000 atoms

Performance: 8.794 ns/day, 2.729 hours/ns, 101.784 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.5201     | 9.5201     | 9.5201     |   0.0 | 96.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.034506   | 0.034506   | 0.034506   |   0.0 |  0.35
Output  | 4.66e-05   | 4.66e-05   | 4.66e-05   |   0.0 |  0.00
Modify  | 0.24763    | 0.24763    | 0.24763    |   0.0 |  2.52
Other   |            | 0.02237    |            |       |  0.23

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:      275036.0 ave      275036 max      275036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0