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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.324999988079071*${_u_distance}
variable latticeconst_converted equal 3.324999988079071*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  3.32499998807907
Lattice spacing in x,y,z = 3.3250000 3.3250000 3.3250000
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 (33.250000 33.250000 33.250000)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (33.250000 33.250000 33.250000)
  create_atoms CPU = 0.008 seconds

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

kim_interactions C

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

kim interactions C
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_NouranianTschoppGwaltney_2014_CH__MO_354152387712_001
pair_coeff * * C
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 12.0107

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_354152387712_001#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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.509 | 9.509 | 9.509 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -58615.539   -58615.539       -58960       -58960       333.15       333.15    36759.953    36759.953     10008.91     10008.91 
    1000   -58259.708   -58259.708   -58620.939   -58620.939    349.36878    349.36878     37440.26     37440.26   -1433.7579   -1433.7579 
Loop time of 271.579 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.318 ns/day, 75.439 hours/ns, 3.682 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    | 269.81     | 269.81     | 269.81     |   0.0 | 99.35
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.29909    | 0.29909    | 0.29909    |   0.0 |  0.11
Output  | 0.0002765  | 0.0002765  | 0.0002765  |   0.0 |  0.00
Modify  | 1.3052     | 1.3052     | 1.3052     |   0.0 |  0.48
Other   |            | 0.1641     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        10629.0 ave       10629 max       10629 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:      976000.0 ave      976000 max      976000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 976000
Ave neighs/atom = 122.00000
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -58259.708   -58259.708   -58620.939   -58620.939    349.36878    349.36878     37440.26     37440.26   -1433.7579   -1433.7579 
    2000   -58290.381   -58290.381   -58631.649   -58631.649    330.06206    330.06206    37411.294    37411.294   -329.53904   -329.53904 
Loop time of 306.153 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.282 ns/day, 85.042 hours/ns, 3.266 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 304.06     | 304.06     | 304.06     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.30366    | 0.30366    | 0.30366    |   0.0 |  0.10
Output  | 0.00033517 | 0.00033517 | 0.00033517 |   0.0 |  0.00
Modify  | 1.5981     | 1.5981     | 1.5981     |   0.0 |  0.52
Other   |            | 0.1865     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9360.00 ave        9360 max        9360 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:      916520.0 ave      916520 max      916520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916520
Ave neighs/atom = 114.56500
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.751 | 9.751 | 9.751 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -58290.381   -58290.381   -58631.649   -58631.649    330.06206    330.06206    37411.294    37411.294   -329.53904   -329.53904 
    3000   -58282.161   -58282.161    -58627.84    -58627.84    334.32798    334.32798    37414.101    37414.101   -314.35539   -314.35539 
Loop time of 308.345 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.280 ns/day, 85.651 hours/ns, 3.243 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 306.25     | 306.25     | 306.25     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.30489    | 0.30489    | 0.30489    |   0.0 |  0.10
Output  | 0.00034325 | 0.00034325 | 0.00034325 |   0.0 |  0.00
Modify  | 1.6032     | 1.6032     | 1.6032     |   0.0 |  0.52
Other   |            | 0.1888     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9470.00 ave        9470 max        9470 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:      917494.0 ave      917494 max      917494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917494
Ave neighs/atom = 114.68675
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -58282.161   -58282.161    -58627.84    -58627.84    334.32798    334.32798    37414.101    37414.101   -314.35539   -314.35539 
    4000   -58277.528   -58277.528    -58623.22    -58623.22    334.34036    334.34036    37412.368    37412.368    415.36067    415.36067 
Loop time of 260.146 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.332 ns/day, 72.263 hours/ns, 3.844 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    | 258.43     | 258.43     | 258.43     |   0.0 | 99.34
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.26279    | 0.26279    | 0.26279    |   0.0 |  0.10
Output  | 0.00026035 | 0.00026035 | 0.00026035 |   0.0 |  0.00
Modify  | 1.296      | 1.296      | 1.296      |   0.0 |  0.50
Other   |            | 0.1621     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9424.00 ave        9424 max        9424 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:      918114.0 ave      918114 max      918114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918114
Ave neighs/atom = 114.76425
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -58277.528   -58277.528    -58623.22    -58623.22    334.34036    334.34036    37412.368    37412.368    415.36067    415.36067 
    5000    -58289.06    -58289.06   -58634.274   -58634.274    333.87905    333.87905    37386.312    37386.312    1844.6293    1844.6293 
Loop time of 284.302 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.973 hours/ns, 3.517 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.38     | 282.38     | 282.38     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2813     | 0.2813     | 0.2813     |   0.0 |  0.10
Output  | 0.00033277 | 0.00033277 | 0.00033277 |   0.0 |  0.00
Modify  | 1.4608     | 1.4608     | 1.4608     |   0.0 |  0.51
Other   |            | 0.1762     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9433.00 ave        9433 max        9433 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:      917750.0 ave      917750 max      917750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917750
Ave neighs/atom = 114.71875
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 = 330.962987921568, Press = -453.528802912428
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -58289.06    -58289.06   -58634.274   -58634.274    333.87905    333.87905    37386.312    37386.312    1844.6293    1844.6293 
    6000   -58275.729   -58275.729   -58628.223   -58628.223    340.91991    340.91991    37400.148    37400.148    927.56775    927.56775 
Loop time of 261.516 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.330 ns/day, 72.643 hours/ns, 3.824 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    | 259.75     | 259.75     | 259.75     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.26452    | 0.26452    | 0.26452    |   0.0 |  0.10
Output  | 0.00022446 | 0.00022446 | 0.00022446 |   0.0 |  0.00
Modify  | 1.3425     | 1.3425     | 1.3425     |   0.0 |  0.51
Other   |            | 0.1629     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9419.00 ave        9419 max        9419 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:      919300.0 ave      919300 max      919300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 919300
Ave neighs/atom = 114.91250
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 = 332.917280100638, Press = 105.672123858604
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -58275.729   -58275.729   -58628.223   -58628.223    340.91991    340.91991    37400.148    37400.148    927.56775    927.56775 
    7000   -58286.954   -58286.954    -58624.21    -58624.21    326.18164    326.18164     37446.97     37446.97   -3394.0681   -3394.0681 
Loop time of 257.363 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.490 hours/ns, 3.886 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    | 255.63     | 255.63     | 255.63     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25814    | 0.25814    | 0.25814    |   0.0 |  0.10
Output  | 0.00022676 | 0.00022676 | 0.00022676 |   0.0 |  0.00
Modify  | 1.3141     | 1.3141     | 1.3141     |   0.0 |  0.51
Other   |            | 0.1603     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9382.00 ave        9382 max        9382 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:      918140.0 ave      918140 max      918140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918140
Ave neighs/atom = 114.76750
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 = 332.89873878504, Press = 1.53738240143207
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -58286.954   -58286.954    -58624.21    -58624.21    326.18164    326.18164     37446.97     37446.97   -3394.0681   -3394.0681 
    8000   -58280.953   -58280.953   -58626.205   -58626.205    333.91467    333.91467    37414.687    37414.687   -315.97029   -315.97029 
Loop time of 257.376 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.493 hours/ns, 3.885 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    | 255.64     | 255.64     | 255.64     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.26016    | 0.26016    | 0.26016    |   0.0 |  0.10
Output  | 0.00022395 | 0.00022395 | 0.00022395 |   0.0 |  0.00
Modify  | 1.3176     | 1.3176     | 1.3176     |   0.0 |  0.51
Other   |            | 0.1617     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9383.00 ave        9383 max        9383 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:      916422.0 ave      916422 max      916422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916422
Ave neighs/atom = 114.55275
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 = 333.124301011322, Press = -26.8233643322758
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -58280.953   -58280.953   -58626.205   -58626.205    333.91467    333.91467    37414.687    37414.687   -315.97029   -315.97029 
    9000   -58279.783   -58279.783   -58626.337   -58626.337     335.1746     335.1746    37394.341    37394.341     1593.347     1593.347 
Loop time of 257.744 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.335 ns/day, 71.596 hours/ns, 3.880 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    | 256        | 256        | 256        |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.26006    | 0.26006    | 0.26006    |   0.0 |  0.10
Output  | 0.00027397 | 0.00027397 | 0.00027397 |   0.0 |  0.00
Modify  | 1.323      | 1.323      | 1.323      |   0.0 |  0.51
Other   |            | 0.162      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9362.00 ave        9362 max        9362 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:      918106.0 ave      918106 max      918106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918106
Ave neighs/atom = 114.76325
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 = 333.011433202222, Press = -6.39175650699134
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -58279.783   -58279.783   -58626.337   -58626.337     335.1746     335.1746    37394.341    37394.341     1593.347     1593.347 
   10000   -58287.817   -58287.817   -58629.013   -58629.013     329.9914     329.9914    37399.021    37399.021    1020.8833    1020.8833 
Loop time of 257.823 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.335 ns/day, 71.618 hours/ns, 3.879 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    | 256.08     | 256.08     | 256.08     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25991    | 0.25991    | 0.25991    |   0.0 |  0.10
Output  | 0.00022498 | 0.00022498 | 0.00022498 |   0.0 |  0.00
Modify  | 1.3244     | 1.3244     | 1.3244     |   0.0 |  0.51
Other   |            | 0.1629     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9338.00 ave        9338 max        9338 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:      918762.0 ave      918762 max      918762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918762
Ave neighs/atom = 114.84525
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 = 333.076573011077, Press = 8.47427366695247
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -58287.817   -58287.817   -58629.013   -58629.013     329.9914     329.9914    37399.021    37399.021    1020.8833    1020.8833 
   11000   -58279.075   -58279.075   -58624.921   -58624.921    334.48962    334.48962    37447.672    37447.672      -3331.7      -3331.7 
Loop time of 257.709 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.335 ns/day, 71.586 hours/ns, 3.880 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    | 255.96     | 255.96     | 255.96     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.26042    | 0.26042    | 0.26042    |   0.0 |  0.10
Output  | 0.00022411 | 0.00022411 | 0.00022411 |   0.0 |  0.00
Modify  | 1.3256     | 1.3256     | 1.3256     |   0.0 |  0.51
Other   |            | 0.1618     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9375.00 ave        9375 max        9375 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:      917824.0 ave      917824 max      917824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917824
Ave neighs/atom = 114.72800
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 = 333.137013192834, Press = -0.503573338096468
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -58279.075   -58279.075   -58624.921   -58624.921    334.48962    334.48962    37447.672    37447.672      -3331.7      -3331.7 
   12000    -58273.18    -58273.18   -58619.248   -58619.248    334.70437    334.70437    37429.345    37429.345   -646.68943   -646.68943 
Loop time of 257.31 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.475 hours/ns, 3.886 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 255.56     | 255.56     | 255.56     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25975    | 0.25975    | 0.25975    |   0.0 |  0.10
Output  | 0.00022697 | 0.00022697 | 0.00022697 |   0.0 |  0.00
Modify  | 1.3232     | 1.3232     | 1.3232     |   0.0 |  0.51
Other   |            | 0.1625     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9401.00 ave        9401 max        9401 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:      916416.0 ave      916416 max      916416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916416
Ave neighs/atom = 114.55200
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 = 333.166324352553, Press = -16.5075829092517
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -58273.18    -58273.18   -58619.248   -58619.248    334.70437    334.70437    37429.345    37429.345   -646.68943   -646.68943 
   13000   -58283.806   -58283.806   -58627.025   -58627.025    331.94959    331.94959    37380.668    37380.668    3181.0051    3181.0051 
Loop time of 257.315 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.476 hours/ns, 3.886 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    | 255.57     | 255.57     | 255.57     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25841    | 0.25841    | 0.25841    |   0.0 |  0.10
Output  | 0.00028802 | 0.00028802 | 0.00028802 |   0.0 |  0.00
Modify  | 1.3256     | 1.3256     | 1.3256     |   0.0 |  0.52
Other   |            | 0.1614     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9339.00 ave        9339 max        9339 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:      916652.0 ave      916652 max      916652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916652
Ave neighs/atom = 114.58150
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 = 333.312093144788, Press = -1.32213062505389
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -58283.806   -58283.806   -58627.025   -58627.025    331.94959    331.94959    37380.668    37380.668    3181.0051    3181.0051 
   14000   -58275.687   -58275.687   -58623.132   -58623.132    336.03603    336.03603    37423.693    37423.693   -163.96521   -163.96521 
Loop time of 257.74 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.335 ns/day, 71.595 hours/ns, 3.880 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    | 256        | 256        | 256        |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25864    | 0.25864    | 0.25864    |   0.0 |  0.10
Output  | 0.00022867 | 0.00022867 | 0.00022867 |   0.0 |  0.00
Modify  | 1.3232     | 1.3232     | 1.3232     |   0.0 |  0.51
Other   |            | 0.162      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9367.00 ave        9367 max        9367 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:      918842.0 ave      918842 max      918842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918842
Ave neighs/atom = 114.85525
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 = 333.463286012823, Press = 8.77920997732011
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -58275.687   -58275.687   -58623.132   -58623.132    336.03603    336.03603    37423.693    37423.693   -163.96521   -163.96521 
   15000   -58285.257   -58285.257   -58628.478   -58628.478    331.95065    331.95065    37444.439    37444.439   -3309.5357   -3309.5357 
Loop time of 257.093 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.415 hours/ns, 3.890 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    | 255.35     | 255.35     | 255.35     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25905    | 0.25905    | 0.25905    |   0.0 |  0.10
Output  | 0.00022671 | 0.00022671 | 0.00022671 |   0.0 |  0.00
Modify  | 1.3202     | 1.3202     | 1.3202     |   0.0 |  0.51
Other   |            | 0.1619     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9393.00 ave        9393 max        9393 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:      916740.0 ave      916740 max      916740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916740
Ave neighs/atom = 114.59250
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 = 333.46141672321, Press = -4.49457134752332
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -58285.257   -58285.257   -58628.478   -58628.478    331.95065    331.95065    37444.439    37444.439   -3309.5357   -3309.5357 
   16000   -58276.677   -58276.677   -58625.772   -58625.772    337.63228    337.63228    37414.142    37414.142    114.60193    114.60193 
Loop time of 256.851 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.348 hours/ns, 3.893 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    | 255.11     | 255.11     | 255.11     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25817    | 0.25817    | 0.25817    |   0.0 |  0.10
Output  | 0.00022591 | 0.00022591 | 0.00022591 |   0.0 |  0.00
Modify  | 1.3176     | 1.3176     | 1.3176     |   0.0 |  0.51
Other   |            | 0.1608     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9427.00 ave        9427 max        9427 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:      916592.0 ave      916592 max      916592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916592
Ave neighs/atom = 114.57400
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 = 333.505943106516, Press = -9.09382499984172
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.751 | 9.751 | 9.751 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -58276.677   -58276.677   -58625.772   -58625.772    337.63228    337.63228    37414.142    37414.142    114.60193    114.60193 
   17000   -58281.764   -58281.764   -58630.575   -58630.575    337.35637    337.35637    37390.389    37390.389    1560.8159    1560.8159 
Loop time of 256.972 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.381 hours/ns, 3.891 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    | 255.23     | 255.23     | 255.23     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25923    | 0.25923    | 0.25923    |   0.0 |  0.10
Output  | 0.00022837 | 0.00022837 | 0.00022837 |   0.0 |  0.00
Modify  | 1.3168     | 1.3168     | 1.3168     |   0.0 |  0.51
Other   |            | 0.162      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9475.00 ave        9475 max        9475 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:      917502.0 ave      917502 max      917502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917502
Ave neighs/atom = 114.68775
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 = 333.510833052274, Press = 0.494787701556798
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -58281.764   -58281.764   -58630.575   -58630.575    337.35637    337.35637    37390.389    37390.389    1560.8159    1560.8159 
   18000   -58283.519   -58283.519   -58626.761   -58626.761     331.9709     331.9709    37414.994    37414.994    -233.9544    -233.9544 
Loop time of 257.173 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.437 hours/ns, 3.888 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 255.43     | 255.43     | 255.43     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.26116    | 0.26116    | 0.26116    |   0.0 |  0.10
Output  | 0.00022542 | 0.00022542 | 0.00022542 |   0.0 |  0.00
Modify  | 1.3172     | 1.3172     | 1.3172     |   0.0 |  0.51
Other   |            | 0.162      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9459.00 ave        9459 max        9459 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:      918746.0 ave      918746 max      918746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918746
Ave neighs/atom = 114.84325
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 = 333.497738394365, Press = 2.42806244351785
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -58283.519   -58283.519   -58626.761   -58626.761     331.9709     331.9709    37414.994    37414.994    -233.9544    -233.9544 
   19000   -58280.166   -58280.166   -58626.498   -58626.498    334.95929    334.95929    37436.787    37436.787   -2137.4039   -2137.4039 
Loop time of 257.122 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.423 hours/ns, 3.889 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    | 255.39     | 255.39     | 255.39     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25992    | 0.25992    | 0.25992    |   0.0 |  0.10
Output  | 0.00022431 | 0.00022431 | 0.00022431 |   0.0 |  0.00
Modify  | 1.3154     | 1.3154     | 1.3154     |   0.0 |  0.51
Other   |            | 0.1616     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9446.00 ave        9446 max        9446 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:      917708.0 ave      917708 max      917708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917708
Ave neighs/atom = 114.71350
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 = 333.366579804573, Press = -3.33785027390959
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -58280.166   -58280.166   -58626.498   -58626.498    334.95929    334.95929    37436.787    37436.787   -2137.4039   -2137.4039 
   20000   -58284.545   -58284.545   -58629.573   -58629.573    333.69828    333.69828    37405.728    37405.728    266.27462    266.27462 
Loop time of 256.978 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.383 hours/ns, 3.891 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    | 255.24     | 255.24     | 255.24     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2595     | 0.2595     | 0.2595     |   0.0 |  0.10
Output  | 0.00022553 | 0.00022553 | 0.00022553 |   0.0 |  0.00
Modify  | 1.3162     | 1.3162     | 1.3162     |   0.0 |  0.51
Other   |            | 0.161      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9383.00 ave        9383 max        9383 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:      916716.0 ave      916716 max      916716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916716
Ave neighs/atom = 114.58950
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 = 333.36671015958, Press = -7.00694333616426
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -58284.545   -58284.545   -58629.573   -58629.573    333.69828    333.69828    37405.728    37405.728    266.27462    266.27462 
   21000   -58278.751   -58278.751   -58625.548   -58625.548    335.40929    335.40929    37389.387    37389.387    2379.0579    2379.0579 
Loop time of 257.147 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.430 hours/ns, 3.889 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    | 255.41     | 255.41     | 255.41     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25808    | 0.25808    | 0.25808    |   0.0 |  0.10
Output  | 0.00022477 | 0.00022477 | 0.00022477 |   0.0 |  0.00
Modify  | 1.3156     | 1.3156     | 1.3156     |   0.0 |  0.51
Other   |            | 0.1611     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9381.00 ave        9381 max        9381 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:      917816.0 ave      917816 max      917816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917816
Ave neighs/atom = 114.72700
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 = 333.45038442332, Press = -0.0129682437109641
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -58278.751   -58278.751   -58625.548   -58625.548    335.40929    335.40929    37389.387    37389.387    2379.0579    2379.0579 
   22000   -58277.972   -58277.972   -58624.858   -58624.858    335.49576    335.49576    37437.673    37437.673   -1938.3265   -1938.3265 
Loop time of 257.18 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.336 ns/day, 71.439 hours/ns, 3.888 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 255.44     | 255.44     | 255.44     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25858    | 0.25858    | 0.25858    |   0.0 |  0.10
Output  | 0.00022603 | 0.00022603 | 0.00022603 |   0.0 |  0.00
Modify  | 1.3173     | 1.3173     | 1.3173     |   0.0 |  0.51
Other   |            | 0.1613     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9421.00 ave        9421 max        9421 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:      918416.0 ave      918416 max      918416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918416
Ave neighs/atom = 114.80200
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 = 333.439523957012, Press = 3.66932168757258
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -58277.972   -58277.972   -58624.858   -58624.858    335.49576    335.49576    37437.673    37437.673   -1938.3265   -1938.3265 
   23000   -58287.896   -58287.896   -58626.653   -58626.653    327.63323    327.63323    37443.247    37443.247   -3264.3818   -3264.3818 
Loop time of 256.68 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.337 ns/day, 71.300 hours/ns, 3.896 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    | 254.94     | 254.94     | 254.94     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25816    | 0.25816    | 0.25816    |   0.0 |  0.10
Output  | 0.00027235 | 0.00027235 | 0.00027235 |   0.0 |  0.00
Modify  | 1.3154     | 1.3154     | 1.3154     |   0.0 |  0.51
Other   |            | 0.1616     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9395.00 ave        9395 max        9395 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:      916520.0 ave      916520 max      916520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916520
Ave neighs/atom = 114.56500
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 = 333.442892493349, Press = -5.38921952005993
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -58287.896   -58287.896   -58626.653   -58626.653    327.63323    327.63323    37443.247    37443.247   -3264.3818   -3264.3818 
   24000   -58277.788   -58277.788   -58623.979   -58623.979    334.82302    334.82302    37390.692    37390.692    2204.2359    2204.2359 
Loop time of 256.672 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.337 ns/day, 71.298 hours/ns, 3.896 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    | 254.94     | 254.94     | 254.94     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25769    | 0.25769    | 0.25769    |   0.0 |  0.10
Output  | 0.00022627 | 0.00022627 | 0.00022627 |   0.0 |  0.00
Modify  | 1.3161     | 1.3161     | 1.3161     |   0.0 |  0.51
Other   |            | 0.1616     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9358.00 ave        9358 max        9358 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:      916438.0 ave      916438 max      916438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916438
Ave neighs/atom = 114.55475
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 = 333.428857030971, Press = -5.37234682053144
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -58277.788   -58277.788   -58623.979   -58623.979    334.82302    334.82302    37390.692    37390.692    2204.2359    2204.2359 
   25000   -58284.647   -58284.647   -58629.765   -58629.765    333.78582    333.78582    37394.612    37394.612    1566.8868    1566.8868 
Loop time of 245.09 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.353 ns/day, 68.080 hours/ns, 4.080 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    | 243.4      | 243.4      | 243.4      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2552     | 0.2552     | 0.2552     |   0.0 |  0.10
Output  | 0.0002161  | 0.0002161  | 0.0002161  |   0.0 |  0.00
Modify  | 1.2761     | 1.2761     | 1.2761     |   0.0 |  0.52
Other   |            | 0.1564     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9358.00 ave        9358 max        9358 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:      917850.0 ave      917850 max      917850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917850
Ave neighs/atom = 114.73125
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 = 333.420695123401, Press = -0.0780632870642736
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -58284.647   -58284.647   -58629.765   -58629.765    333.78582    333.78582    37394.612    37394.612    1566.8868    1566.8868 
   26000   -58280.307   -58280.307   -58624.699   -58624.699    333.08262    333.08262    37416.125    37416.125   -275.23081   -275.23081 
Loop time of 243.631 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.675 hours/ns, 4.105 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    | 241.94     | 241.94     | 241.94     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25676    | 0.25676    | 0.25676    |   0.0 |  0.11
Output  | 0.00021184 | 0.00021184 | 0.00021184 |   0.0 |  0.00
Modify  | 1.2752     | 1.2752     | 1.2752     |   0.0 |  0.52
Other   |            | 0.1546     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9394.00 ave        9394 max        9394 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:      918088.0 ave      918088 max      918088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918088
Ave neighs/atom = 114.76100
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 = 333.49155856783, Press = -1.14995580176453
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -58280.307   -58280.307   -58624.699   -58624.699    333.08262    333.08262    37416.125    37416.125   -275.23081   -275.23081 
   27000   -58279.294   -58279.294   -58623.738   -58623.738    333.13374    333.13374    37420.771    37420.771   -766.39426   -766.39426 
Loop time of 243.82 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.728 hours/ns, 4.101 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    | 242.14     | 242.14     | 242.14     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25497    | 0.25497    | 0.25497    |   0.0 |  0.10
Output  | 0.00021424 | 0.00021424 | 0.00021424 |   0.0 |  0.00
Modify  | 1.2722     | 1.2722     | 1.2722     |   0.0 |  0.52
Other   |            | 0.1567     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9371.00 ave        9371 max        9371 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:      917552.0 ave      917552 max      917552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917552
Ave neighs/atom = 114.69400
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 = 333.487920442862, Press = -0.996191135384034
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -58279.294   -58279.294   -58623.738   -58623.738    333.13374    333.13374    37420.771    37420.771   -766.39426   -766.39426 
   28000   -58281.825   -58281.825   -58622.845   -58622.845    329.82185    329.82185    37434.072    37434.072   -1602.3997   -1602.3997 
Loop time of 243.49 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.636 hours/ns, 4.107 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    | 241.8      | 241.8      | 241.8      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2549     | 0.2549     | 0.2549     |   0.0 |  0.10
Output  | 0.0002151  | 0.0002151  | 0.0002151  |   0.0 |  0.00
Modify  | 1.2766     | 1.2766     | 1.2766     |   0.0 |  0.52
Other   |            | 0.1542     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9334.00 ave        9334 max        9334 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:      917070.0 ave      917070 max      917070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917070
Ave neighs/atom = 114.63375
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 = 333.531735551501, Press = -3.44834846301513
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -58281.825   -58281.825   -58622.845   -58622.845    329.82185    329.82185    37434.072    37434.072   -1602.3997   -1602.3997 
   29000   -58282.894   -58282.894   -58631.055   -58631.055    336.72787    336.72787    37378.055    37378.055     3185.228     3185.228 
Loop time of 243.745 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.707 hours/ns, 4.103 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    | 242.06     | 242.06     | 242.06     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2554     | 0.2554     | 0.2554     |   0.0 |  0.10
Output  | 0.0002281  | 0.0002281  | 0.0002281  |   0.0 |  0.00
Modify  | 1.2741     | 1.2741     | 1.2741     |   0.0 |  0.52
Other   |            | 0.1564     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9383.00 ave        9383 max        9383 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:      916356.0 ave      916356 max      916356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916356
Ave neighs/atom = 114.54450
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 = 333.503550661938, Press = -3.77486584735708
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -58282.894   -58282.894   -58631.055   -58631.055    336.72787    336.72787    37378.055    37378.055     3185.228     3185.228 
   30000   -58277.322   -58277.322   -58624.774   -58624.774     336.0428     336.0428    37397.415    37397.415    1677.3208    1677.3208 
Loop time of 244.186 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.830 hours/ns, 4.095 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    | 242.5      | 242.5      | 242.5      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25636    | 0.25636    | 0.25636    |   0.0 |  0.10
Output  | 0.00021438 | 0.00021438 | 0.00021438 |   0.0 |  0.00
Modify  | 1.2754     | 1.2754     | 1.2754     |   0.0 |  0.52
Other   |            | 0.1553     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9441.00 ave        9441 max        9441 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:      918800.0 ave      918800 max      918800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918800
Ave neighs/atom = 114.85000
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 = 333.552752056398, Press = 2.29121053378588
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -58277.322   -58277.322   -58624.774   -58624.774     336.0428     336.0428    37397.415    37397.415    1677.3208    1677.3208 
   31000   -58278.767   -58278.767   -58627.348   -58627.348    337.13425    337.13425    37432.119    37432.119   -1268.9918   -1268.9918 
Loop time of 243.716 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.699 hours/ns, 4.103 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    | 242.03     | 242.03     | 242.03     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25866    | 0.25866    | 0.25866    |   0.0 |  0.11
Output  | 0.00021769 | 0.00021769 | 0.00021769 |   0.0 |  0.00
Modify  | 1.2747     | 1.2747     | 1.2747     |   0.0 |  0.52
Other   |            | 0.1538     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9386.00 ave        9386 max        9386 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:      917826.0 ave      917826 max      917826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917826
Ave neighs/atom = 114.72825
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 = 333.533409350179, Press = -0.181198883258347
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -58278.767   -58278.767   -58627.348   -58627.348    337.13425    337.13425    37432.119    37432.119   -1268.9918   -1268.9918 
   32000   -58286.632   -58286.632   -58631.487   -58631.487    333.53161    333.53161    37421.739    37421.739    -1382.726    -1382.726 
Loop time of 243.539 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.650 hours/ns, 4.106 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    | 241.85     | 241.85     | 241.85     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.26067    | 0.26067    | 0.26067    |   0.0 |  0.11
Output  | 0.00027622 | 0.00027622 | 0.00027622 |   0.0 |  0.00
Modify  | 1.2741     | 1.2741     | 1.2741     |   0.0 |  0.52
Other   |            | 0.1539     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9438.00 ave        9438 max        9438 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:      916374.0 ave      916374 max      916374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916374
Ave neighs/atom = 114.54675
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 = 333.518523711976, Press = -2.98474307498757
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -58286.632   -58286.632   -58631.487   -58631.487    333.53161    333.53161    37421.739    37421.739    -1382.726    -1382.726 
   33000    -58280.53    -58280.53   -58625.008   -58625.008    333.16599    333.16599    37398.975    37398.975    1652.2736    1652.2736 
Loop time of 243.719 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.700 hours/ns, 4.103 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    | 242.04     | 242.04     | 242.04     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25564    | 0.25564    | 0.25564    |   0.0 |  0.10
Output  | 0.00024767 | 0.00024767 | 0.00024767 |   0.0 |  0.00
Modify  | 1.2725     | 1.2725     | 1.2725     |   0.0 |  0.52
Other   |            | 0.1544     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9397.00 ave        9397 max        9397 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:      917272.0 ave      917272 max      917272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917272
Ave neighs/atom = 114.65900
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 = 333.464750705193, Press = -1.90399336610166
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -58280.53    -58280.53   -58625.008   -58625.008    333.16599    333.16599    37398.975    37398.975    1652.2736    1652.2736 
   34000   -58289.775   -58289.775   -58628.538   -58628.538    327.63876    327.63876    37402.521    37402.521    484.94475    484.94475 
Loop time of 243.69 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.692 hours/ns, 4.104 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    | 242        | 242        | 242        |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25797    | 0.25797    | 0.25797    |   0.0 |  0.11
Output  | 0.00021335 | 0.00021335 | 0.00021335 |   0.0 |  0.00
Modify  | 1.2723     | 1.2723     | 1.2723     |   0.0 |  0.52
Other   |            | 0.1552     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9420.00 ave        9420 max        9420 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:      917722.0 ave      917722 max      917722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917722
Ave neighs/atom = 114.71525
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 = 333.404263710435, Press = 0.590706497317488
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -58289.775   -58289.775   -58628.538   -58628.538    327.63876    327.63876    37402.521    37402.521    484.94475    484.94475 
   35000   -58286.809   -58286.809   -58626.213   -58626.213    328.25857    328.25857    37405.536    37405.536     1079.756     1079.756 
Loop time of 243.49 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.636 hours/ns, 4.107 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    | 241.8      | 241.8      | 241.8      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25687    | 0.25687    | 0.25687    |   0.0 |  0.11
Output  | 0.00021468 | 0.00021468 | 0.00021468 |   0.0 |  0.00
Modify  | 1.2744     | 1.2744     | 1.2744     |   0.0 |  0.52
Other   |            | 0.1542     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9428.00 ave        9428 max        9428 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:      917770.0 ave      917770 max      917770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917770
Ave neighs/atom = 114.72125
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 = 333.401825949794, Press = -1.23755348354511
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -58286.809   -58286.809   -58626.213   -58626.213    328.25857    328.25857    37405.536    37405.536     1079.756     1079.756 
   36000   -58278.015   -58278.015   -58628.371   -58628.371    338.85132    338.85132    37420.929    37420.929   -501.98804   -501.98804 
Loop time of 243.29 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.580 hours/ns, 4.110 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    | 241.61     | 241.61     | 241.61     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25633    | 0.25633    | 0.25633    |   0.0 |  0.11
Output  | 0.0002542  | 0.0002542  | 0.0002542  |   0.0 |  0.00
Modify  | 1.2701     | 1.2701     | 1.2701     |   0.0 |  0.52
Other   |            | 0.1544     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9406.00 ave        9406 max        9406 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:      916908.0 ave      916908 max      916908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916908
Ave neighs/atom = 114.61350
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 = 333.411173973358, Press = -0.249937333388237
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -58278.015   -58278.015   -58628.371   -58628.371    338.85132    338.85132    37420.929    37420.929   -501.98804   -501.98804 
   37000   -58283.787   -58283.787   -58629.053   -58629.053     333.9292     333.9292    37436.642    37436.642    -2234.907    -2234.907 
Loop time of 243.239 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.567 hours/ns, 4.111 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    | 241.55     | 241.55     | 241.55     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25884    | 0.25884    | 0.25884    |   0.0 |  0.11
Output  | 0.00025394 | 0.00025394 | 0.00025394 |   0.0 |  0.00
Modify  | 1.2707     | 1.2707     | 1.2707     |   0.0 |  0.52
Other   |            | 0.1558     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9443.00 ave        9443 max        9443 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:      917048.0 ave      917048 max      917048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917048
Ave neighs/atom = 114.63100
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 = 333.402630805054, Press = -3.07170771999454
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -58283.787   -58283.787   -58629.053   -58629.053     333.9292     333.9292    37436.642    37436.642    -2234.907    -2234.907 
   38000   -58283.349   -58283.349    -58627.44    -58627.44    332.79222    332.79222    37374.203    37374.203    3724.8878    3724.8878 
Loop time of 243.463 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.628 hours/ns, 4.107 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    | 241.78     | 241.78     | 241.78     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25774    | 0.25774    | 0.25774    |   0.0 |  0.11
Output  | 0.0002166  | 0.0002166  | 0.0002166  |   0.0 |  0.00
Modify  | 1.2729     | 1.2729     | 1.2729     |   0.0 |  0.52
Other   |            | 0.155      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9444.00 ave        9444 max        9444 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:      916368.0 ave      916368 max      916368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916368
Ave neighs/atom = 114.54600
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 = 333.405057270764, Press = -3.4020225621648
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -58283.349   -58283.349    -58627.44    -58627.44    332.79222    332.79222    37374.203    37374.203    3724.8878    3724.8878 
   39000   -58274.407   -58274.407   -58625.979   -58625.979    340.02773    340.02773    37406.078    37406.078    1355.7059    1355.7059 
Loop time of 243.793 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.720 hours/ns, 4.102 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    | 242.11     | 242.11     | 242.11     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25533    | 0.25533    | 0.25533    |   0.0 |  0.10
Output  | 0.00022138 | 0.00022138 | 0.00022138 |   0.0 |  0.00
Modify  | 1.2704     | 1.2704     | 1.2704     |   0.0 |  0.52
Other   |            | 0.1548     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9384.00 ave        9384 max        9384 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:      918768.0 ave      918768 max      918768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918768
Ave neighs/atom = 114.84600
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 = 333.419061863691, Press = 1.78426765026155
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -58274.407   -58274.407   -58625.979   -58625.979    340.02773    340.02773    37406.078    37406.078    1355.7059    1355.7059 
   40000   -58284.526   -58284.526     -58627.3     -58627.3    331.51762    331.51762    37428.255    37428.255   -1460.6211   -1460.6211 
Loop time of 243.566 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.657 hours/ns, 4.106 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    | 241.88     | 241.88     | 241.88     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25606    | 0.25606    | 0.25606    |   0.0 |  0.11
Output  | 0.00022053 | 0.00022053 | 0.00022053 |   0.0 |  0.00
Modify  | 1.2733     | 1.2733     | 1.2733     |   0.0 |  0.52
Other   |            | 0.1549     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9381.00 ave        9381 max        9381 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:      917168.0 ave      917168 max      917168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917168
Ave neighs/atom = 114.64600
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 = 333.446260723242, Press = -0.636320241303989
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -58284.526   -58284.526     -58627.3     -58627.3    331.51762    331.51762    37428.255    37428.255   -1460.6211   -1460.6211 
   41000   -58283.706   -58283.706   -58625.188   -58625.188    330.26883    330.26883    37412.459    37412.459    489.70665    489.70665 
Loop time of 243.361 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.600 hours/ns, 4.109 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    | 241.68     | 241.68     | 241.68     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25601    | 0.25601    | 0.25601    |   0.0 |  0.11
Output  | 0.00021541 | 0.00021541 | 0.00021541 |   0.0 |  0.00
Modify  | 1.2715     | 1.2715     | 1.2715     |   0.0 |  0.52
Other   |            | 0.1567     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9371.00 ave        9371 max        9371 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:      917236.0 ave      917236 max      917236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917236
Ave neighs/atom = 114.65450
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 = 333.470842203543, Press = -2.10465237331188
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -58283.706   -58283.706   -58625.188   -58625.188    330.26883    330.26883    37412.459    37412.459    489.70665    489.70665 
   42000    -58284.54    -58284.54   -58625.473   -58625.473    329.73791    329.73791    37407.557    37407.557    540.30446    540.30446 
Loop time of 243.56 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.656 hours/ns, 4.106 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    | 241.88     | 241.88     | 241.88     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25586    | 0.25586    | 0.25586    |   0.0 |  0.11
Output  | 0.0002809  | 0.0002809  | 0.0002809  |   0.0 |  0.00
Modify  | 1.2717     | 1.2717     | 1.2717     |   0.0 |  0.52
Other   |            | 0.1548     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9374.00 ave        9374 max        9374 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:      917314.0 ave      917314 max      917314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917314
Ave neighs/atom = 114.66425
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 = 333.460034330333, Press = -0.729340682289804
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000    -58284.54    -58284.54   -58625.473   -58625.473    329.73791    329.73791    37407.557    37407.557    540.30446    540.30446 
   43000   -58283.044   -58283.044    -58626.79    -58626.79    332.45787    332.45787    37410.911    37410.911    261.28175    261.28175 
Loop time of 243.442 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.623 hours/ns, 4.108 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    | 241.76     | 241.76     | 241.76     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25711    | 0.25711    | 0.25711    |   0.0 |  0.11
Output  | 0.00027695 | 0.00027695 | 0.00027695 |   0.0 |  0.00
Modify  | 1.2728     | 1.2728     | 1.2728     |   0.0 |  0.52
Other   |            | 0.1537     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9410.00 ave        9410 max        9410 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:      918058.0 ave      918058 max      918058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918058
Ave neighs/atom = 114.75725
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 = 333.455106245031, Press = -0.15957151239029
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -58283.044   -58283.044    -58626.79    -58626.79    332.45787    332.45787    37410.911    37410.911    261.28175    261.28175 
   44000    -58283.57    -58283.57    -58625.07    -58625.07    330.28621    330.28621    37412.548    37412.548    406.63355    406.63355 
Loop time of 243.308 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.585 hours/ns, 4.110 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    | 241.62     | 241.62     | 241.62     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25875    | 0.25875    | 0.25875    |   0.0 |  0.11
Output  | 0.00021947 | 0.00021947 | 0.00021947 |   0.0 |  0.00
Modify  | 1.2721     | 1.2721     | 1.2721     |   0.0 |  0.52
Other   |            | 0.1554     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9418.00 ave        9418 max        9418 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:      917444.0 ave      917444 max      917444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917444
Ave neighs/atom = 114.68050
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 = 333.429695345772, Press = -1.21676418622776
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000    -58283.57    -58283.57    -58625.07    -58625.07    330.28621    330.28621    37412.548    37412.548    406.63355    406.63355 
   45000   -58280.268   -58280.268   -58626.483   -58626.483    334.84651    334.84651    37409.188    37409.188    854.71732    854.71732 
Loop time of 243.356 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.599 hours/ns, 4.109 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    | 241.67     | 241.67     | 241.67     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25538    | 0.25538    | 0.25538    |   0.0 |  0.10
Output  | 0.00021377 | 0.00021377 | 0.00021377 |   0.0 |  0.00
Modify  | 1.2719     | 1.2719     | 1.2719     |   0.0 |  0.52
Other   |            | 0.155      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9381.00 ave        9381 max        9381 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:      917486.0 ave      917486 max      917486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917486
Ave neighs/atom = 114.68575
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 = 333.437899002649, Press = -0.806444546148235
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -58280.268   -58280.268   -58626.483   -58626.483    334.84651    334.84651    37409.188    37409.188    854.71732    854.71732 
   46000   -58273.476   -58273.476   -58622.165   -58622.165    337.23938    337.23938    37436.386    37436.386   -1432.9471   -1432.9471 
Loop time of 243.558 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.655 hours/ns, 4.106 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    | 241.87     | 241.87     | 241.87     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25804    | 0.25804    | 0.25804    |   0.0 |  0.11
Output  | 0.00021554 | 0.00021554 | 0.00021554 |   0.0 |  0.00
Modify  | 1.2703     | 1.2703     | 1.2703     |   0.0 |  0.52
Other   |            | 0.1549     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9404.00 ave        9404 max        9404 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:      917790.0 ave      917790 max      917790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917790
Ave neighs/atom = 114.72375
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 = 333.436189623714, Press = 0.0373731705015174
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -58273.476   -58273.476   -58622.165   -58622.165    337.23938    337.23938    37436.386    37436.386   -1432.9471   -1432.9471 
   47000   -58284.065   -58284.065   -58627.095   -58627.095    331.76619    331.76619    37425.219    37425.219    -941.5836    -941.5836 
Loop time of 243.299 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.583 hours/ns, 4.110 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    | 241.62     | 241.62     | 241.62     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25773    | 0.25773    | 0.25773    |   0.0 |  0.11
Output  | 0.0002788  | 0.0002788  | 0.0002788  |   0.0 |  0.00
Modify  | 1.2717     | 1.2717     | 1.2717     |   0.0 |  0.52
Other   |            | 0.1536     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9371.00 ave        9371 max        9371 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:      916592.0 ave      916592 max      916592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916592
Ave neighs/atom = 114.57400
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 = 333.45503784423, Press = -3.23992293710964
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -58284.065   -58284.065   -58627.095   -58627.095    331.76619    331.76619    37425.219    37425.219    -941.5836    -941.5836 
   48000   -58269.774   -58269.774   -58626.409   -58626.409    344.92419    344.92419    37383.576    37383.576    3308.5294    3308.5294 
Loop time of 243.569 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.658 hours/ns, 4.106 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    | 241.89     | 241.89     | 241.89     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25595    | 0.25595    | 0.25595    |   0.0 |  0.11
Output  | 0.00021386 | 0.00021386 | 0.00021386 |   0.0 |  0.00
Modify  | 1.2711     | 1.2711     | 1.2711     |   0.0 |  0.52
Other   |            | 0.1546     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9367.00 ave        9367 max        9367 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:      917186.0 ave      917186 max      917186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917186
Ave neighs/atom = 114.64825
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 = 333.487369790368, Press = -1.53760852401755
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -58269.774   -58269.774   -58626.409   -58626.409    344.92419    344.92419    37383.576    37383.576    3308.5294    3308.5294 
   49000   -58283.908   -58283.908   -58623.895   -58623.895    328.82216    328.82216    37414.459    37414.459     316.5274     316.5274 
Loop time of 243.744 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.707 hours/ns, 4.103 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    | 242.05     | 242.05     | 242.05     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2589     | 0.2589     | 0.2589     |   0.0 |  0.11
Output  | 0.00024522 | 0.00024522 | 0.00024522 |   0.0 |  0.00
Modify  | 1.2748     | 1.2748     | 1.2748     |   0.0 |  0.52
Other   |            | 0.1555     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9457.00 ave        9457 max        9457 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:      918552.0 ave      918552 max      918552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918552
Ave neighs/atom = 114.81900
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 = 333.489382645432, Press = 0.781037070103488
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -58283.908   -58283.908   -58623.895   -58623.895    328.82216    328.82216    37414.459    37414.459     316.5274     316.5274 
   50000   -58285.219   -58285.219   -58628.246   -58628.246    331.76362    331.76362    37421.898    37421.898   -1151.9683   -1151.9683 
Loop time of 243.433 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.620 hours/ns, 4.108 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    | 241.75     | 241.75     | 241.75     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25547    | 0.25547    | 0.25547    |   0.0 |  0.10
Output  | 0.00021688 | 0.00021688 | 0.00021688 |   0.0 |  0.00
Modify  | 1.2728     | 1.2728     | 1.2728     |   0.0 |  0.52
Other   |            | 0.154      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9401.00 ave        9401 max        9401 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:      917154.0 ave      917154 max      917154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917154
Ave neighs/atom = 114.64425
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 = 333.486102034835, Press = -1.03652687693943
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -58285.219   -58285.219   -58628.246   -58628.246    331.76362    331.76362    37421.898    37421.898   -1151.9683   -1151.9683 
   51000   -58283.433   -58283.433   -58626.399   -58626.399    331.70359    331.70359    37405.528    37405.528    340.64912    340.64912 
Loop time of 243.836 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.732 hours/ns, 4.101 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    | 242.15     | 242.15     | 242.15     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25585    | 0.25585    | 0.25585    |   0.0 |  0.10
Output  | 0.00028725 | 0.00028725 | 0.00028725 |   0.0 |  0.00
Modify  | 1.2769     | 1.2769     | 1.2769     |   0.0 |  0.52
Other   |            | 0.1552     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9386.00 ave        9386 max        9386 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:      917360.0 ave      917360 max      917360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917360
Ave neighs/atom = 114.67000
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 = 333.446789427853, Press = -1.38225312126376
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -58283.433   -58283.433   -58626.399   -58626.399    331.70359    331.70359    37405.528    37405.528    340.64912    340.64912 
   52000   -58283.158   -58283.158   -58628.117   -58628.117    333.63215    333.63215    37398.881    37398.881     1127.437     1127.437 
Loop time of 243.722 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.700 hours/ns, 4.103 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    | 242.04     | 242.04     | 242.04     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25746    | 0.25746    | 0.25746    |   0.0 |  0.11
Output  | 0.00021595 | 0.00021595 | 0.00021595 |   0.0 |  0.00
Modify  | 1.2713     | 1.2713     | 1.2713     |   0.0 |  0.52
Other   |            | 0.1546     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9433.00 ave        9433 max        9433 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:      918284.0 ave      918284 max      918284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918284
Ave neighs/atom = 114.78550
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 = 333.448665772123, Press = -0.149443736353034
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -58283.158   -58283.158   -58628.117   -58628.117    333.63215    333.63215    37398.881    37398.881     1127.437     1127.437 
   53000   -58272.861   -58272.861   -58621.299   -58621.299    336.99621    336.99621    37446.972    37446.972   -2614.3308   -2614.3308 
Loop time of 243.815 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.726 hours/ns, 4.101 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    | 242.13     | 242.13     | 242.13     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25671    | 0.25671    | 0.25671    |   0.0 |  0.11
Output  | 0.00021609 | 0.00021609 | 0.00021609 |   0.0 |  0.00
Modify  | 1.2734     | 1.2734     | 1.2734     |   0.0 |  0.52
Other   |            | 0.154      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9370.00 ave        9370 max        9370 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:      918082.0 ave      918082 max      918082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918082
Ave neighs/atom = 114.76025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.463581393864, Press = -0.0260763258878231
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -58272.861   -58272.861   -58621.299   -58621.299    336.99621    336.99621    37446.972    37446.972   -2614.3308   -2614.3308 
   54000   -58284.414   -58284.414   -58626.658   -58626.658    331.00591    331.00591    37426.579    37426.579    -1723.824    -1723.824 
Loop time of 243.703 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.695 hours/ns, 4.103 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    | 242.02     | 242.02     | 242.02     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25848    | 0.25848    | 0.25848    |   0.0 |  0.11
Output  | 0.00021598 | 0.00021598 | 0.00021598 |   0.0 |  0.00
Modify  | 1.2731     | 1.2731     | 1.2731     |   0.0 |  0.52
Other   |            | 0.1542     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9396.00 ave        9396 max        9396 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:      916622.0 ave      916622 max      916622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916622
Ave neighs/atom = 114.57775
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 = 333.472400394955, Press = -2.98662983911098
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -58284.414   -58284.414   -58626.658   -58626.658    331.00591    331.00591    37426.579    37426.579    -1723.824    -1723.824 
   55000   -58274.092   -58274.092   -58620.522   -58620.522     335.0551     335.0551    37390.316    37390.316    3207.9081    3207.9081 
Loop time of 243.367 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.602 hours/ns, 4.109 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    | 241.68     | 241.68     | 241.68     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25643    | 0.25643    | 0.25643    |   0.0 |  0.11
Output  | 0.00028197 | 0.00028197 | 0.00028197 |   0.0 |  0.00
Modify  | 1.2728     | 1.2728     | 1.2728     |   0.0 |  0.52
Other   |            | 0.1565     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9421.00 ave        9421 max        9421 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:      917340.0 ave      917340 max      917340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917340
Ave neighs/atom = 114.66750
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 = 333.493002842687, Press = -1.10870339754971
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -58274.092   -58274.092   -58620.522   -58620.522     335.0551     335.0551    37390.316    37390.316    3207.9081    3207.9081 
   56000   -58282.721   -58282.721   -58624.336   -58624.336    330.39783    330.39783    37407.716    37407.716    862.21655    862.21655 
Loop time of 243.5 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.639 hours/ns, 4.107 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    | 241.82     | 241.82     | 241.82     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2563     | 0.2563     | 0.2563     |   0.0 |  0.11
Output  | 0.0016494  | 0.0016494  | 0.0016494  |   0.0 |  0.00
Modify  | 1.2711     | 1.2711     | 1.2711     |   0.0 |  0.52
Other   |            | 0.1555     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9434.00 ave        9434 max        9434 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:      917762.0 ave      917762 max      917762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917762
Ave neighs/atom = 114.72025
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 = 333.494636453465, Press = 0.72045036763899
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -58282.721   -58282.721   -58624.336   -58624.336    330.39783    330.39783    37407.716    37407.716    862.21655    862.21655 
   57000   -58279.562   -58279.562   -58626.643   -58626.643     335.6832     335.6832    37434.189    37434.189   -1807.6799   -1807.6799 
Loop time of 243.38 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.606 hours/ns, 4.109 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    | 241.7      | 241.7      | 241.7      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25558    | 0.25558    | 0.25558    |   0.0 |  0.11
Output  | 0.0002226  | 0.0002226  | 0.0002226  |   0.0 |  0.00
Modify  | 1.2729     | 1.2729     | 1.2729     |   0.0 |  0.52
Other   |            | 0.1547     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9374.00 ave        9374 max        9374 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:      917736.0 ave      917736 max      917736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917736
Ave neighs/atom = 114.71700
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 = 333.503170954211, Press = -0.662881813866357
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -58279.562   -58279.562   -58626.643   -58626.643     335.6832     335.6832    37434.189    37434.189   -1807.6799   -1807.6799 
   58000   -58278.383   -58278.383   -58623.965   -58623.965    334.23439    334.23439    37421.462    37421.462   -692.00856   -692.00856 
Loop time of 243.555 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.654 hours/ns, 4.106 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    | 241.87     | 241.87     | 241.87     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25793    | 0.25793    | 0.25793    |   0.0 |  0.11
Output  | 0.00021697 | 0.00021697 | 0.00021697 |   0.0 |  0.00
Modify  | 1.2725     | 1.2725     | 1.2725     |   0.0 |  0.52
Other   |            | 0.1548     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9411.00 ave        9411 max        9411 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:      916972.0 ave      916972 max      916972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916972
Ave neighs/atom = 114.62150
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 = 333.488491900851, Press = -1.06021766689197
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -58278.383   -58278.383   -58623.965   -58623.965    334.23439    334.23439    37421.462    37421.462   -692.00856   -692.00856 
   59000   -58282.952   -58282.952   -58630.017   -58630.017    335.66843    335.66843    37407.459    37407.459    10.395435    10.395435 
Loop time of 243.302 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.584 hours/ns, 4.110 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    | 241.62     | 241.62     | 241.62     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25633    | 0.25633    | 0.25633    |   0.0 |  0.11
Output  | 0.0002756  | 0.0002756  | 0.0002756  |   0.0 |  0.00
Modify  | 1.2729     | 1.2729     | 1.2729     |   0.0 |  0.52
Other   |            | 0.1542     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9391.00 ave        9391 max        9391 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:      917738.0 ave      917738 max      917738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917738
Ave neighs/atom = 114.71725
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 = 333.488628860558, Press = -0.90945504341212
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.751 | 9.751 | 9.751 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -58282.952   -58282.952   -58630.017   -58630.017    335.66843    335.66843    37407.459    37407.459    10.395435    10.395435 
   60000    -58279.72    -58279.72   -58626.086   -58626.086    334.99166    334.99166     37415.01     37415.01   -214.52617   -214.52617 
Loop time of 243.626 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.674 hours/ns, 4.105 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    | 241.94     | 241.94     | 241.94     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25739    | 0.25739    | 0.25739    |   0.0 |  0.11
Output  | 0.00034835 | 0.00034835 | 0.00034835 |   0.0 |  0.00
Modify  | 1.2709     | 1.2709     | 1.2709     |   0.0 |  0.52
Other   |            | 0.1559     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9470.00 ave        9470 max        9470 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:      918236.0 ave      918236 max      918236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918236
Ave neighs/atom = 114.77950
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 = 333.480095166425, Press = -0.618909844704452
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000    -58279.72    -58279.72   -58626.086   -58626.086    334.99166    334.99166     37415.01     37415.01   -214.52617   -214.52617 
   61000   -58278.163   -58278.163   -58621.156   -58621.156    331.73004    331.73004    37414.426    37414.426    633.55354    633.55354 
Loop time of 243.703 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.695 hours/ns, 4.103 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    | 242.02     | 242.02     | 242.02     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25542    | 0.25542    | 0.25542    |   0.0 |  0.10
Output  | 0.00021489 | 0.00021489 | 0.00021489 |   0.0 |  0.00
Modify  | 1.2713     | 1.2713     | 1.2713     |   0.0 |  0.52
Other   |            | 0.1552     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9408.00 ave        9408 max        9408 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:      917786.0 ave      917786 max      917786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917786
Ave neighs/atom = 114.72325
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 = 333.481199355847, Press = -0.914814692449287
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -58278.163   -58278.163   -58621.156   -58621.156    331.73004    331.73004    37414.426    37414.426    633.55354    633.55354 
   62000    -58282.51    -58282.51   -58627.682   -58627.682    333.83766    333.83766    37411.833    37411.833   -316.56185   -316.56185 
Loop time of 243.545 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.651 hours/ns, 4.106 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    | 241.87     | 241.87     | 241.87     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25594    | 0.25594    | 0.25594    |   0.0 |  0.11
Output  | 0.00028521 | 0.00028521 | 0.00028521 |   0.0 |  0.00
Modify  | 1.2694     | 1.2694     | 1.2694     |   0.0 |  0.52
Other   |            | 0.1543     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9354.00 ave        9354 max        9354 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:      917604.0 ave      917604 max      917604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917604
Ave neighs/atom = 114.70050
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 = 333.450859679833, Press = -0.592166077287978
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000    -58282.51    -58282.51   -58627.682   -58627.682    333.83766    333.83766    37411.833    37411.833   -316.56185   -316.56185 
   63000   -58282.734   -58282.734   -58626.127   -58626.127    332.11719    332.11719    37414.798    37414.798   -292.40715   -292.40715 
Loop time of 243.572 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.659 hours/ns, 4.106 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    | 241.89     | 241.89     | 241.89     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25506    | 0.25506    | 0.25506    |   0.0 |  0.10
Output  | 0.00031881 | 0.00031881 | 0.00031881 |   0.0 |  0.00
Modify  | 1.273      | 1.273      | 1.273      |   0.0 |  0.52
Other   |            | 0.1566     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9413.00 ave        9413 max        9413 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:      917686.0 ave      917686 max      917686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917686
Ave neighs/atom = 114.71075
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 = 333.439499950316, Press = -1.2428308423919
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -58282.734   -58282.734   -58626.127   -58626.127    332.11719    332.11719    37414.798    37414.798   -292.40715   -292.40715 
   64000   -58278.419   -58278.419   -58624.985   -58624.985    335.18505    335.18505    37401.525    37401.525    1417.3531    1417.3531 
Loop time of 243.555 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.654 hours/ns, 4.106 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    | 241.87     | 241.87     | 241.87     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25606    | 0.25606    | 0.25606    |   0.0 |  0.11
Output  | 0.00021479 | 0.00021479 | 0.00021479 |   0.0 |  0.00
Modify  | 1.2735     | 1.2735     | 1.2735     |   0.0 |  0.52
Other   |            | 0.1558     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9375.00 ave        9375 max        9375 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:      917274.0 ave      917274 max      917274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917274
Ave neighs/atom = 114.65925
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 = 333.432147837208, Press = -0.843906470264863
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -58278.419   -58278.419   -58624.985   -58624.985    335.18505    335.18505    37401.525    37401.525    1417.3531    1417.3531 
   65000    -58283.86    -58283.86   -58629.423   -58629.423    334.21603    334.21603    37407.684    37407.684    462.02753    462.02753 
Loop time of 243.727 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.702 hours/ns, 4.103 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    | 242.04     | 242.04     | 242.04     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25652    | 0.25652    | 0.25652    |   0.0 |  0.11
Output  | 0.00021577 | 0.00021577 | 0.00021577 |   0.0 |  0.00
Modify  | 1.2747     | 1.2747     | 1.2747     |   0.0 |  0.52
Other   |            | 0.155      |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9430.00 ave        9430 max        9430 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:      918164.0 ave      918164 max      918164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918164
Ave neighs/atom = 114.77050
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 = 333.426783952422, Press = -0.0621341787739457
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000    -58283.86    -58283.86   -58629.423   -58629.423    334.21603    334.21603    37407.684    37407.684    462.02753    462.02753 
   66000   -58285.427   -58285.427   -58630.907   -58630.907    334.13541    334.13541    37432.274    37432.274   -2317.9926   -2317.9926 
Loop time of 243.463 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.629 hours/ns, 4.107 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    | 241.78     | 241.78     | 241.78     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25519    | 0.25519    | 0.25519    |   0.0 |  0.10
Output  | 0.00028079 | 0.00028079 | 0.00028079 |   0.0 |  0.00
Modify  | 1.2732     | 1.2732     | 1.2732     |   0.0 |  0.52
Other   |            | 0.1539     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9411.00 ave        9411 max        9411 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:      917550.0 ave      917550 max      917550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917550
Ave neighs/atom = 114.69375
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 = 333.426203118497, Press = -0.975793907178346
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -58285.427   -58285.427   -58630.907   -58630.907    334.13541    334.13541    37432.274    37432.274   -2317.9926   -2317.9926 
   67000   -58286.753   -58286.753    -58631.01    -58631.01    332.95271    332.95271    37395.944    37395.944    865.03019    865.03019 
Loop time of 243.414 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.615 hours/ns, 4.108 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    | 241.73     | 241.73     | 241.73     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25523    | 0.25523    | 0.25523    |   0.0 |  0.10
Output  | 0.00021479 | 0.00021479 | 0.00021479 |   0.0 |  0.00
Modify  | 1.2732     | 1.2732     | 1.2732     |   0.0 |  0.52
Other   |            | 0.1552     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9383.00 ave        9383 max        9383 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:      916956.0 ave      916956 max      916956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916956
Ave neighs/atom = 114.61950
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 = 333.415838718253, Press = -1.81298989272786
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -58286.753   -58286.753    -58631.01    -58631.01    332.95271    332.95271    37395.944    37395.944    865.03019    865.03019 
   68000   -58281.801   -58281.801   -58627.844   -58627.844    334.68017    334.68017    37395.547    37395.547    1559.4061    1559.4061 
Loop time of 243.528 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.647 hours/ns, 4.106 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    | 241.85     | 241.85     | 241.85     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25458    | 0.25458    | 0.25458    |   0.0 |  0.10
Output  | 0.00027671 | 0.00027671 | 0.00027671 |   0.0 |  0.00
Modify  | 1.2713     | 1.2713     | 1.2713     |   0.0 |  0.52
Other   |            | 0.1552     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9397.00 ave        9397 max        9397 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:      918512.0 ave      918512 max      918512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918512
Ave neighs/atom = 114.81400
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 = 333.419393767654, Press = 0.0869270793611381
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -58281.801   -58281.801   -58627.844   -58627.844    334.68017    334.68017    37395.547    37395.547    1559.4061    1559.4061 
   69000   -58280.872   -58280.872   -58621.866   -58621.866    329.79673    329.79673    37447.631    37447.631   -2839.4031   -2839.4031 
Loop time of 243.813 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.726 hours/ns, 4.102 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    | 242.13     | 242.13     | 242.13     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25627    | 0.25627    | 0.25627    |   0.0 |  0.11
Output  | 0.00022688 | 0.00022688 | 0.00022688 |   0.0 |  0.00
Modify  | 1.2736     | 1.2736     | 1.2736     |   0.0 |  0.52
Other   |            | 0.1547     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9361.00 ave        9361 max        9361 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:      918096.0 ave      918096 max      918096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918096
Ave neighs/atom = 114.76200
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 = 333.414116844543, Press = -0.166477763616251
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -58280.872   -58280.872   -58621.866   -58621.866    329.79673    329.79673    37447.631    37447.631   -2839.4031   -2839.4031 
   70000   -58284.456   -58284.456   -58627.824   -58627.824    332.09208    332.09208    37423.611    37423.611   -1075.0053   -1075.0053 
Loop time of 243.29 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.581 hours/ns, 4.110 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    | 241.6      | 241.6      | 241.6      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2557     | 0.2557     | 0.2557     |   0.0 |  0.11
Output  | 0.00021798 | 0.00021798 | 0.00021798 |   0.0 |  0.00
Modify  | 1.2733     | 1.2733     | 1.2733     |   0.0 |  0.52
Other   |            | 0.1565     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9370.00 ave        9370 max        9370 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:      916070.0 ave      916070 max      916070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916070
Ave neighs/atom = 114.50875
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 = 333.416508199336, Press = -2.16778185936002
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -58284.456   -58284.456   -58627.824   -58627.824    332.09208    332.09208    37423.611    37423.611   -1075.0053   -1075.0053 
   71000   -58280.729   -58280.729   -58629.287   -58629.287     337.1122     337.1122      37396.7      37396.7    1821.6111    1821.6111 
Loop time of 243.771 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.714 hours/ns, 4.102 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    | 242.08     | 242.08     | 242.08     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25747    | 0.25747    | 0.25747    |   0.0 |  0.11
Output  | 0.00021554 | 0.00021554 | 0.00021554 |   0.0 |  0.00
Modify  | 1.2736     | 1.2736     | 1.2736     |   0.0 |  0.52
Other   |            | 0.1568     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9431.00 ave        9431 max        9431 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:      917464.0 ave      917464 max      917464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917464
Ave neighs/atom = 114.68300
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 = 333.407754799818, Press = -0.918866156969341
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -58280.729   -58280.729   -58629.287   -58629.287     337.1122     337.1122      37396.7      37396.7    1821.6111    1821.6111 
   72000   -58282.561   -58282.561   -58626.485   -58626.485    332.63028    332.63028     37420.23     37420.23   -347.35462   -347.35462 
Loop time of 243.954 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.765 hours/ns, 4.099 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    | 242.27     | 242.27     | 242.27     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25775    | 0.25775    | 0.25775    |   0.0 |  0.11
Output  | 0.00027681 | 0.00027681 | 0.00027681 |   0.0 |  0.00
Modify  | 1.2739     | 1.2739     | 1.2739     |   0.0 |  0.52
Other   |            | 0.1564     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9410.00 ave        9410 max        9410 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:      918612.0 ave      918612 max      918612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918612
Ave neighs/atom = 114.82650
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 = 333.403956768607, Press = -0.312749740843391
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -58282.561   -58282.561   -58626.485   -58626.485    332.63028    332.63028     37420.23     37420.23   -347.35462   -347.35462 
   73000   -58282.379   -58282.379    -58624.72    -58624.72    331.09911    331.09911    37423.202    37423.202   -510.60839   -510.60839 
Loop time of 243.596 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.665 hours/ns, 4.105 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    | 241.91     | 241.91     | 241.91     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2551     | 0.2551     | 0.2551     |   0.0 |  0.10
Output  | 0.000216   | 0.000216   | 0.000216   |   0.0 |  0.00
Modify  | 1.2741     | 1.2741     | 1.2741     |   0.0 |  0.52
Other   |            | 0.1557     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9342.00 ave        9342 max        9342 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:      917464.0 ave      917464 max      917464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917464
Ave neighs/atom = 114.68300
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 = 333.379586322318, Press = -0.839838219926627
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -58282.379   -58282.379    -58624.72    -58624.72    331.09911    331.09911    37423.202    37423.202   -510.60839   -510.60839 
   74000   -58292.851   -58292.851   -58630.934   -58630.934    326.98099    326.98099    37402.003    37402.003    590.89042    590.89042 
Loop time of 243.231 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.564 hours/ns, 4.111 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    | 241.55     | 241.55     | 241.55     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25603    | 0.25603    | 0.25603    |   0.0 |  0.11
Output  | 0.00021534 | 0.00021534 | 0.00021534 |   0.0 |  0.00
Modify  | 1.2727     | 1.2727     | 1.2727     |   0.0 |  0.52
Other   |            | 0.1554     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9364.00 ave        9364 max        9364 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:      916528.0 ave      916528 max      916528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916528
Ave neighs/atom = 114.56600
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 = 333.360368153801, Press = -0.999621156941556
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -58292.851   -58292.851   -58630.934   -58630.934    326.98099    326.98099    37402.003    37402.003    590.89042    590.89042 
   75000   -58284.233   -58284.233   -58633.401   -58633.401     337.7023     337.7023     37418.42     37418.42   -679.76374   -679.76374 
Loop time of 243.353 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.598 hours/ns, 4.109 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    | 241.67     | 241.67     | 241.67     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25381    | 0.25381    | 0.25381    |   0.0 |  0.10
Output  | 0.00027842 | 0.00027842 | 0.00027842 |   0.0 |  0.00
Modify  | 1.2706     | 1.2706     | 1.2706     |   0.0 |  0.52
Other   |            | 0.1558     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9372.00 ave        9372 max        9372 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:      917944.0 ave      917944 max      917944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917944
Ave neighs/atom = 114.74300
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 = 333.34953389562, Press = -0.735471990214054
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -58284.233   -58284.233   -58633.401   -58633.401     337.7023     337.7023     37418.42     37418.42   -679.76374   -679.76374 
   76000   -58277.798   -58277.798   -58625.406   -58625.406    336.19365    336.19365    37432.269    37432.269   -1288.2943   -1288.2943 
Loop time of 243.334 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.593 hours/ns, 4.110 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    | 241.65     | 241.65     | 241.65     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25719    | 0.25719    | 0.25719    |   0.0 |  0.11
Output  | 0.00028083 | 0.00028083 | 0.00028083 |   0.0 |  0.00
Modify  | 1.2711     | 1.2711     | 1.2711     |   0.0 |  0.52
Other   |            | 0.1544     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9436.00 ave        9436 max        9436 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:      916856.0 ave      916856 max      916856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916856
Ave neighs/atom = 114.60700
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 = 333.343584143242, Press = -0.777459865548662
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -58277.798   -58277.798   -58625.406   -58625.406    336.19365    336.19365    37432.269    37432.269   -1288.2943   -1288.2943 
   77000   -58289.152   -58289.152   -58628.212   -58628.212    327.92602    327.92602    37406.154    37406.154    809.20657    809.20657 
Loop time of 243.352 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.598 hours/ns, 4.109 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    | 241.66     | 241.66     | 241.66     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25618    | 0.25618    | 0.25618    |   0.0 |  0.11
Output  | 0.00028204 | 0.00028204 | 0.00028204 |   0.0 |  0.00
Modify  | 1.2759     | 1.2759     | 1.2759     |   0.0 |  0.52
Other   |            | 0.1556     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9402.00 ave        9402 max        9402 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:      916684.0 ave      916684 max      916684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916684
Ave neighs/atom = 114.58550
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 = 333.34875853624, Press = -1.76326292627334
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -58289.152   -58289.152   -58628.212   -58628.212    327.92602    327.92602    37406.154    37406.154    809.20657    809.20657 
   78000   -58279.884   -58279.884   -58625.587   -58625.587    334.35146    334.35146    37380.688    37380.688    3282.6155    3282.6155 
Loop time of 243.487 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.635 hours/ns, 4.107 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    | 241.8      | 241.8      | 241.8      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25848    | 0.25848    | 0.25848    |   0.0 |  0.11
Output  | 0.0002693  | 0.0002693  | 0.0002693  |   0.0 |  0.00
Modify  | 1.2748     | 1.2748     | 1.2748     |   0.0 |  0.52
Other   |            | 0.1548     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9451.00 ave        9451 max        9451 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:      917616.0 ave      917616 max      917616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917616
Ave neighs/atom = 114.70200
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 = 333.350255719499, Press = -0.446511647536502
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -58279.884   -58279.884   -58625.587   -58625.587    334.35146    334.35146    37380.688    37380.688    3282.6155    3282.6155 
   79000    -58281.33    -58281.33   -58625.145   -58625.145    332.52477    332.52477    37434.241    37434.241   -1449.1283   -1449.1283 
Loop time of 243.788 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.354 ns/day, 67.719 hours/ns, 4.102 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    | 242.1      | 242.1      | 242.1      |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25888    | 0.25888    | 0.25888    |   0.0 |  0.11
Output  | 0.00021718 | 0.00021718 | 0.00021718 |   0.0 |  0.00
Modify  | 1.2739     | 1.2739     | 1.2739     |   0.0 |  0.52
Other   |            | 0.1568     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9399.00 ave        9399 max        9399 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:      918306.0 ave      918306 max      918306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 918306
Ave neighs/atom = 114.78825
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 = 333.333096931039, Press = 0.886785232652721
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000    -58281.33    -58281.33   -58625.145   -58625.145    332.52477    332.52477    37434.241    37434.241   -1449.1283   -1449.1283 
   80000   -58288.418   -58288.418   -58627.304   -58627.304    327.75847    327.75847    37426.226    37426.226   -1135.3417   -1135.3417 
Loop time of 243.327 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.591 hours/ns, 4.110 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    | 241.64     | 241.64     | 241.64     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25732    | 0.25732    | 0.25732    |   0.0 |  0.11
Output  | 0.00028008 | 0.00028008 | 0.00028008 |   0.0 |  0.00
Modify  | 1.2744     | 1.2744     | 1.2744     |   0.0 |  0.52
Other   |            | 0.1559     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9441.00 ave        9441 max        9441 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:      916662.0 ave      916662 max      916662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916662
Ave neighs/atom = 114.58275
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 = 333.318288890424, Press = -1.37999875659266
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -58288.418   -58288.418   -58627.304   -58627.304    327.75847    327.75847    37426.226    37426.226   -1135.3417   -1135.3417 
   81000   -58277.964   -58277.964    -58622.79    -58622.79    333.50309    333.50309     37411.65     37411.65    1035.9181    1035.9181 
Loop time of 243.366 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.602 hours/ns, 4.109 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    | 241.68     | 241.68     | 241.68     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2557     | 0.2557     | 0.2557     |   0.0 |  0.11
Output  | 0.0002216  | 0.0002216  | 0.0002216  |   0.0 |  0.00
Modify  | 1.2733     | 1.2733     | 1.2733     |   0.0 |  0.52
Other   |            | 0.1546     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9396.00 ave        9396 max        9396 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:      916768.0 ave      916768 max      916768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 916768
Ave neighs/atom = 114.59600
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 = 333.322632412909, Press = -1.15663764033419
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
  ghost atom cutoff = 5
  binsize = 2.5, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 9.750 | 9.750 | 9.750 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -58277.964   -58277.964    -58622.79    -58622.79    333.50309    333.50309     37411.65     37411.65    1035.9181    1035.9181 
   82000   -58279.616   -58279.616   -58629.346   -58629.346    338.24625    338.24625    37404.956    37404.956    858.92501    858.92501 
Loop time of 243.408 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.355 ns/day, 67.613 hours/ns, 4.108 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    | 241.72     | 241.72     | 241.72     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25689    | 0.25689    | 0.25689    |   0.0 |  0.11
Output  | 0.00021636 | 0.00021636 | 0.00021636 |   0.0 |  0.00
Modify  | 1.2742     | 1.2742     | 1.2742     |   0.0 |  0.52
Other   |            | 0.1562     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        9370.00 ave        9370 max        9370 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:      917260.0 ave      917260 max      917260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 917260
Ave neighs/atom = 114.65750
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
37412.852920066

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0