# 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 4.045353233814239*${_u_distance}
variable latticeconst_converted equal 4.045353233814239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04535323381424
Lattice spacing in x,y,z = 4.0453532 4.0453532 4.0453532
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 (40.453532 40.453532 40.453532)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.453532 40.453532 40.453532)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_MahataMukhopadhyayAsleZaeem_2022_AlNi__MO_461927113651_000
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66201.7315006764 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_461927113651_000#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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13298.962   -13298.962   -13440.157   -13440.157       273.15       273.15    66201.732    66201.732    2278.0762    2278.0762 
    1000   -13147.031   -13147.031   -13287.701   -13287.701    272.13484    272.13484    67232.174    67232.174    859.58302    859.58302 
Loop time of 185.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.414 hours/ns, 5.403 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 184.43     | 184.43     | 184.43     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08337    | 0.08337    | 0.08337    |   0.0 |  0.05
Output  | 0.00021817 | 0.00021817 | 0.00021817 |   0.0 |  0.00
Modify  | 0.49654    | 0.49654    | 0.49654    |   0.0 |  0.27
Other   |            | 0.07417    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      216000.0 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13147.031   -13147.031   -13287.701   -13287.701    272.13484    272.13484    67232.174    67232.174    859.58302    859.58302 
    2000   -13159.218   -13159.218   -13292.777   -13292.777    258.37952    258.37952     67262.32     67262.32    220.09974    220.09974 
Loop time of 209.675 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.243 hours/ns, 4.769 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 208.94     | 208.94     | 208.94     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.088163   | 0.088163   | 0.088163   |   0.0 |  0.04
Output  | 0.00024596 | 0.00024596 | 0.00024596 |   0.0 |  0.00
Modify  | 0.56197    | 0.56197    | 0.56197    |   0.0 |  0.27
Other   |            | 0.08037    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5695.00 ave        5695 max        5695 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:      223576.0 ave      223576 max      223576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223576
Ave neighs/atom = 55.894000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13159.218   -13159.218   -13292.777   -13292.777    258.37952    258.37952     67262.32     67262.32    220.09974    220.09974 
    3000    -13150.87    -13150.87   -13299.108   -13299.108    286.77644    286.77644    67286.389    67286.389   -245.70048   -245.70048 
Loop time of 229.449 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.736 hours/ns, 4.358 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.67     | 228.67     | 228.67     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10616    | 0.10616    | 0.10616    |   0.0 |  0.05
Output  | 0.00045397 | 0.00045397 | 0.00045397 |   0.0 |  0.00
Modify  | 0.59146    | 0.59146    | 0.59146    |   0.0 |  0.26
Other   |            | 0.08341    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5702.00 ave        5702 max        5702 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:      223336.0 ave      223336 max      223336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223336
Ave neighs/atom = 55.834000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000    -13150.87    -13150.87   -13299.108   -13299.108    286.77644    286.77644    67286.389    67286.389   -245.70048   -245.70048 
    4000   -13157.486   -13157.486   -13295.872   -13295.872    267.71586    267.71586    67273.358    67273.358   -120.80088   -120.80088 
Loop time of 239.47 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.361 ns/day, 66.520 hours/ns, 4.176 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    | 238.67     | 238.67     | 238.67     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096752   | 0.096752   | 0.096752   |   0.0 |  0.04
Output  | 0.00025984 | 0.00025984 | 0.00025984 |   0.0 |  0.00
Modify  | 0.62019    | 0.62019    | 0.62019    |   0.0 |  0.26
Other   |            | 0.08688    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      222628.0 ave      222628 max      222628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222628
Ave neighs/atom = 55.657000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13157.486   -13157.486   -13295.872   -13295.872    267.71586    267.71586    67273.358    67273.358   -120.80088   -120.80088 
    5000   -13152.603   -13152.603   -13294.037   -13294.037    273.61356    273.61356    67331.955    67331.955   -503.80707   -503.80707 
Loop time of 220.659 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.294 hours/ns, 4.532 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    | 219.91     | 219.91     | 219.91     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.090167   | 0.090167   | 0.090167   |   0.0 |  0.04
Output  | 0.00036519 | 0.00036519 | 0.00036519 |   0.0 |  0.00
Modify  | 0.57597    | 0.57597    | 0.57597    |   0.0 |  0.26
Other   |            | 0.08192    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5699.00 ave        5699 max        5699 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:      223032.0 ave      223032 max      223032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223032
Ave neighs/atom = 55.758000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 277.31624044464, Press = -232.457052983027
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13152.603   -13152.603   -13294.037   -13294.037    273.61356    273.61356    67331.955    67331.955   -503.80707   -503.80707 
    6000   -13155.077   -13155.077   -13298.284   -13298.284    277.04366    277.04366    67371.619    67371.619   -1098.3118   -1098.3118 
Loop time of 224.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.473 hours/ns, 4.446 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.12     | 224.12     | 224.12     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09196    | 0.09196    | 0.09196    |   0.0 |  0.04
Output  | 0.00019782 | 0.00019782 | 0.00019782 |   0.0 |  0.00
Modify  | 0.60118    | 0.60118    | 0.60118    |   0.0 |  0.27
Other   |            | 0.08502    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5687.00 ave        5687 max        5687 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:      223052.0 ave      223052 max      223052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223052
Ave neighs/atom = 55.763000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.783692167378, Press = 1.81535582394324
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13155.077   -13155.077   -13298.284   -13298.284    277.04366    277.04366    67371.619    67371.619   -1098.3118   -1098.3118 
    7000   -13154.773   -13154.773   -13296.683   -13296.683    274.53449    274.53449      67319.3      67319.3   -511.42904   -511.42904 
Loop time of 220.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.122 hours/ns, 4.545 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.25     | 219.25     | 219.25     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.090513   | 0.090513   | 0.090513   |   0.0 |  0.04
Output  | 0.00038457 | 0.00038457 | 0.00038457 |   0.0 |  0.00
Modify  | 0.61614    | 0.61614    | 0.61614    |   0.0 |  0.28
Other   |            | 0.08294    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      222406.0 ave      222406 max      222406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222406
Ave neighs/atom = 55.601500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.387022929692, Press = 13.0421427371604
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13154.773   -13154.773   -13296.683   -13296.683    274.53449    274.53449      67319.3      67319.3   -511.42904   -511.42904 
    8000   -13150.416   -13150.416    -13295.97    -13295.97    281.58584    281.58584    67256.089    67256.089    269.38829    269.38829 
Loop time of 229.742 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.376 ns/day, 63.817 hours/ns, 4.353 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.94     | 228.94     | 228.94     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093757   | 0.093757   | 0.093757   |   0.0 |  0.04
Output  | 0.00020004 | 0.00020004 | 0.00020004 |   0.0 |  0.00
Modify  | 0.61755    | 0.61755    | 0.61755    |   0.0 |  0.27
Other   |            | 0.08601    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5718.00 ave        5718 max        5718 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:      222646.0 ave      222646 max      222646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222646
Ave neighs/atom = 55.661500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.300816122204, Press = 7.92579260836657
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13150.416   -13150.416    -13295.97    -13295.97    281.58584    281.58584    67256.089    67256.089    269.38829    269.38829 
    9000   -13155.698   -13155.698   -13295.425   -13295.425    270.31076    270.31076    67218.666    67218.666    552.03352    552.03352 
Loop time of 220.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.154 hours/ns, 4.542 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.39     | 219.39     | 219.39     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091069   | 0.091069   | 0.091069   |   0.0 |  0.04
Output  | 0.00019978 | 0.00019978 | 0.00019978 |   0.0 |  0.00
Modify  | 0.58922    | 0.58922    | 0.58922    |   0.0 |  0.27
Other   |            | 0.08286    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5742.00 ave        5742 max        5742 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:      222818.0 ave      222818 max      222818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222818
Ave neighs/atom = 55.704500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.424319690919, Press = 0.247880334860022
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13155.698   -13155.698   -13295.425   -13295.425    270.31076    270.31076    67218.666    67218.666    552.03352    552.03352 
   10000    -13152.29    -13152.29    -13294.16    -13294.16    274.45597    274.45597    67242.462    67242.462    370.15546    370.15546 
Loop time of 193.972 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.881 hours/ns, 5.155 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.3      | 193.3      | 193.3      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079842   | 0.079842   | 0.079842   |   0.0 |  0.04
Output  | 0.00019777 | 0.00019777 | 0.00019777 |   0.0 |  0.00
Modify  | 0.52116    | 0.52116    | 0.52116    |   0.0 |  0.27
Other   |            | 0.07565    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5703.00 ave        5703 max        5703 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:      223064.0 ave      223064 max      223064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223064
Ave neighs/atom = 55.766000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.677580905441, Press = -2.05249879031553
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -13152.29    -13152.29    -13294.16    -13294.16    274.45597    274.45597    67242.462    67242.462    370.15546    370.15546 
   11000   -13156.812   -13156.812   -13296.262   -13296.262    269.77512    269.77512    67237.306    67237.306    333.81605    333.81605 
Loop time of 232.417 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.560 hours/ns, 4.303 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.61     | 231.61     | 231.61     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095803   | 0.095803   | 0.095803   |   0.0 |  0.04
Output  | 0.0001932  | 0.0001932  | 0.0001932  |   0.0 |  0.00
Modify  | 0.62176    | 0.62176    | 0.62176    |   0.0 |  0.27
Other   |            | 0.08677    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5722.00 ave        5722 max        5722 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:      223268.0 ave      223268 max      223268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223268
Ave neighs/atom = 55.817000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.590330125838, Press = -2.49137224392285
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13156.812   -13156.812   -13296.262   -13296.262    269.77512    269.77512    67237.306    67237.306    333.81605    333.81605 
   12000    -13153.46    -13153.46   -13292.725   -13292.725    269.41823    269.41823    67241.175    67241.175    401.04473    401.04473 
Loop time of 204.706 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.863 hours/ns, 4.885 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.99     | 203.99     | 203.99     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083653   | 0.083653   | 0.083653   |   0.0 |  0.04
Output  | 0.00034134 | 0.00034134 | 0.00034134 |   0.0 |  0.00
Modify  | 0.54843    | 0.54843    | 0.54843    |   0.0 |  0.27
Other   |            | 0.07885    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5700.00 ave        5700 max        5700 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:      223176.0 ave      223176 max      223176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223176
Ave neighs/atom = 55.794000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.32609621788, Press = -5.1501273399423
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -13153.46    -13153.46   -13292.725   -13292.725    269.41823    269.41823    67241.175    67241.175    401.04473    401.04473 
   13000   -13155.215   -13155.215   -13296.011   -13296.011    272.37912    272.37912    67323.157    67323.157   -502.41138   -502.41138 
Loop time of 225.749 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.708 hours/ns, 4.430 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.96     | 224.96     | 224.96     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094216   | 0.094216   | 0.094216   |   0.0 |  0.04
Output  | 0.00039209 | 0.00039209 | 0.00039209 |   0.0 |  0.00
Modify  | 0.60916    | 0.60916    | 0.60916    |   0.0 |  0.27
Other   |            | 0.08737    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5744.00 ave        5744 max        5744 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:      223458.0 ave      223458 max      223458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223458
Ave neighs/atom = 55.864500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.368209512178, Press = -6.21780465721667
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13155.215   -13155.215   -13296.011   -13296.011    272.37912    272.37912    67323.157    67323.157   -502.41138   -502.41138 
   14000   -13156.256   -13156.256   -13296.554   -13296.554     271.4177     271.4177    67366.678    67366.678   -992.56278   -992.56278 
Loop time of 232.465 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.574 hours/ns, 4.302 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.64     | 231.64     | 231.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09586    | 0.09586    | 0.09586    |   0.0 |  0.04
Output  | 0.00038814 | 0.00038814 | 0.00038814 |   0.0 |  0.00
Modify  | 0.64178    | 0.64178    | 0.64178    |   0.0 |  0.28
Other   |            | 0.089      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      222818.0 ave      222818 max      222818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222818
Ave neighs/atom = 55.704500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.376690729881, Press = -3.41280447253224
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13156.256   -13156.256   -13296.554   -13296.554     271.4177     271.4177    67366.678    67366.678   -992.56278   -992.56278 
   15000     -13150.3     -13150.3   -13294.168   -13294.168    278.32246    278.32246     67349.42     67349.42   -731.36001   -731.36001 
Loop time of 225.496 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.638 hours/ns, 4.435 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    | 224.72     | 224.72     | 224.72     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093137   | 0.093137   | 0.093137   |   0.0 |  0.04
Output  | 0.00027599 | 0.00027599 | 0.00027599 |   0.0 |  0.00
Modify  | 0.60225    | 0.60225    | 0.60225    |   0.0 |  0.27
Other   |            | 0.08482    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5750.00 ave        5750 max        5750 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:      222388.0 ave      222388 max      222388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222388
Ave neighs/atom = 55.597000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.331903680996, Press = -1.00735292320033
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000     -13150.3     -13150.3   -13294.168   -13294.168    278.32246    278.32246     67349.42     67349.42   -731.36001   -731.36001 
   16000   -13155.545   -13155.545   -13296.177   -13296.177    272.06178    272.06178     67283.34     67283.34    -132.1154    -132.1154 
Loop time of 169.755 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.509 ns/day, 47.154 hours/ns, 5.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    | 169.16     | 169.16     | 169.16     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070558   | 0.070558   | 0.070558   |   0.0 |  0.04
Output  | 0.00019073 | 0.00019073 | 0.00019073 |   0.0 |  0.00
Modify  | 0.45772    | 0.45772    | 0.45772    |   0.0 |  0.27
Other   |            | 0.07099    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5718.00 ave        5718 max        5718 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:      222894.0 ave      222894 max      222894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222894
Ave neighs/atom = 55.723500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.470614758672, Press = -0.62999180007251
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13155.545   -13155.545   -13296.177   -13296.177    272.06178    272.06178     67283.34     67283.34    -132.1154    -132.1154 
   17000   -13147.929   -13147.929   -13291.432   -13291.432    277.61488    277.61488    67301.407    67301.407   -75.316108   -75.316108 
Loop time of 187.673 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.460 ns/day, 52.132 hours/ns, 5.328 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    | 187.01     | 187.01     | 187.01     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078736   | 0.078736   | 0.078736   |   0.0 |  0.04
Output  | 9.0437e-05 | 9.0437e-05 | 9.0437e-05 |   0.0 |  0.00
Modify  | 0.50536    | 0.50536    | 0.50536    |   0.0 |  0.27
Other   |            | 0.07674    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5737.00 ave        5737 max        5737 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:      222944.0 ave      222944 max      222944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222944
Ave neighs/atom = 55.736000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.493586036072, Press = -0.511085129954315
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13147.929   -13147.929   -13291.432   -13291.432    277.61488    277.61488    67301.407    67301.407   -75.316108   -75.316108 
   18000   -13155.087   -13155.087   -13295.119   -13295.119    270.90165    270.90165     67273.83     67273.83   -55.155848   -55.155848 
Loop time of 114.214 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.726 hours/ns, 8.755 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.82     | 113.82     | 113.82     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047821   | 0.047821   | 0.047821   |   0.0 |  0.04
Output  | 0.00018967 | 0.00018967 | 0.00018967 |   0.0 |  0.00
Modify  | 0.3032     | 0.3032     | 0.3032     |   0.0 |  0.27
Other   |            | 0.04632    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5715.00 ave        5715 max        5715 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:      223068.0 ave      223068 max      223068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223068
Ave neighs/atom = 55.767000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.547676747312, Press = -0.753921291456342
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13155.087   -13155.087   -13295.119   -13295.119    270.90165    270.90165     67273.83     67273.83   -55.155848   -55.155848 
   19000    -13155.31    -13155.31   -13294.191   -13294.191    268.67463    268.67463     67243.41     67243.41    326.22798    326.22798 
Loop time of 136.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.030 hours/ns, 7.304 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    | 136.43     | 136.43     | 136.43     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056886   | 0.056886   | 0.056886   |   0.0 |  0.04
Output  | 9.9278e-05 | 9.9278e-05 | 9.9278e-05 |   0.0 |  0.00
Modify  | 0.36307    | 0.36307    | 0.36307    |   0.0 |  0.27
Other   |            | 0.05405    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5719.00 ave        5719 max        5719 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:      223356.0 ave      223356 max      223356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223356
Ave neighs/atom = 55.839000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.569103537853, Press = -0.294965777453076
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -13155.31    -13155.31   -13294.191   -13294.191    268.67463    268.67463     67243.41     67243.41    326.22798    326.22798 
   20000   -13154.523   -13154.523   -13293.632   -13293.632    269.11531    269.11531    67225.178    67225.178    519.45245    519.45245 
Loop time of 113.905 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.640 hours/ns, 8.779 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    | 113.51     | 113.51     | 113.51     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047925   | 0.047925   | 0.047925   |   0.0 |  0.04
Output  | 0.00010824 | 0.00010824 | 0.00010824 |   0.0 |  0.00
Modify  | 0.30112    | 0.30112    | 0.30112    |   0.0 |  0.26
Other   |            | 0.04593    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5730.00 ave        5730 max        5730 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:      223262.0 ave      223262 max      223262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223262
Ave neighs/atom = 55.815500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.657001217516, Press = -0.83389212795489
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13154.523   -13154.523   -13293.632   -13293.632    269.11531    269.11531    67225.178    67225.178    519.45245    519.45245 
   21000   -13152.698   -13152.698   -13294.422   -13294.422    274.17574    274.17574    67221.569    67221.569    553.17019    553.17019 
Loop time of 113.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.622 hours/ns, 8.784 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.45     | 113.45     | 113.45     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047518   | 0.047518   | 0.047518   |   0.0 |  0.04
Output  | 0.00010426 | 0.00010426 | 0.00010426 |   0.0 |  0.00
Modify  | 0.30055    | 0.30055    | 0.30055    |   0.0 |  0.26
Other   |            | 0.04544    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5735.00 ave        5735 max        5735 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:      223466.0 ave      223466 max      223466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223466
Ave neighs/atom = 55.866500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.653132946513, Press = -1.97118769655915
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13152.698   -13152.698   -13294.422   -13294.422    274.17574    274.17574    67221.569    67221.569    553.17019    553.17019 
   22000   -13158.354   -13158.354   -13298.733   -13298.733    271.57442    271.57442    67267.972    67267.972   -113.74947   -113.74947 
Loop time of 117.943 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.733 ns/day, 32.762 hours/ns, 8.479 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    | 117.53     | 117.53     | 117.53     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048814   | 0.048814   | 0.048814   |   0.0 |  0.04
Output  | 0.00010063 | 0.00010063 | 0.00010063 |   0.0 |  0.00
Modify  | 0.31238    | 0.31238    | 0.31238    |   0.0 |  0.26
Other   |            | 0.04749    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5717.00 ave        5717 max        5717 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:      223370.0 ave      223370 max      223370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223370
Ave neighs/atom = 55.842500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.595204270548, Press = -2.49907092135507
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13158.354   -13158.354   -13298.733   -13298.733    271.57442    271.57442    67267.972    67267.972   -113.74947   -113.74947 
   23000    -13153.08    -13153.08   -13294.769   -13294.769    274.10827    274.10827    67338.412    67338.412   -627.99719   -627.99719 
Loop time of 117.962 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.732 ns/day, 32.767 hours/ns, 8.477 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    | 117.55     | 117.55     | 117.55     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049397   | 0.049397   | 0.049397   |   0.0 |  0.04
Output  | 9.9566e-05 | 9.9566e-05 | 9.9566e-05 |   0.0 |  0.00
Modify  | 0.31253    | 0.31253    | 0.31253    |   0.0 |  0.26
Other   |            | 0.04751    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5758.00 ave        5758 max        5758 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:      222932.0 ave      222932 max      222932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222932
Ave neighs/atom = 55.733000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.503483761792, Press = -1.68315761199998
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000    -13153.08    -13153.08   -13294.769   -13294.769    274.10827    274.10827    67338.412    67338.412   -627.99719   -627.99719 
   24000    -13149.99    -13149.99   -13293.607   -13293.607     277.8365     277.8365    67379.806    67379.806   -1035.4088   -1035.4088 
Loop time of 131.252 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.658 ns/day, 36.459 hours/ns, 7.619 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    | 130.79     | 130.79     | 130.79     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055435   | 0.055435   | 0.055435   |   0.0 |  0.04
Output  | 9.8971e-05 | 9.8971e-05 | 9.8971e-05 |   0.0 |  0.00
Modify  | 0.3523     | 0.3523     | 0.3523     |   0.0 |  0.27
Other   |            | 0.0549     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5707.00 ave        5707 max        5707 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:      222848.0 ave      222848 max      222848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222848
Ave neighs/atom = 55.712000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.460779699824, Press = -0.283913498979165
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -13149.99    -13149.99   -13293.607   -13293.607     277.8365     277.8365    67379.806    67379.806   -1035.4088   -1035.4088 
   25000   -13154.908   -13154.908   -13294.658   -13294.658    270.35559    270.35559      67323.5      67323.5   -553.60615   -553.60615 
Loop time of 122.809 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.704 ns/day, 34.114 hours/ns, 8.143 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    | 122.38     | 122.38     | 122.38     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051743   | 0.051743   | 0.051743   |   0.0 |  0.04
Output  | 0.00010028 | 0.00010028 | 0.00010028 |   0.0 |  0.00
Modify  | 0.3282     | 0.3282     | 0.3282     |   0.0 |  0.27
Other   |            | 0.05129    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5737.00 ave        5737 max        5737 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:      223020.0 ave      223020 max      223020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223020
Ave neighs/atom = 55.755000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.503708448007, Press = 0.993565261102422
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13154.908   -13154.908   -13294.658   -13294.658    270.35559    270.35559      67323.5      67323.5   -553.60615   -553.60615 
   26000   -13150.205   -13150.205   -13293.596   -13293.596     277.3992     277.3992    67260.193    67260.193    279.49738    279.49738 
Loop time of 113.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.662 hours/ns, 8.773 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.59     | 113.59     | 113.59     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047097   | 0.047097   | 0.047097   |   0.0 |  0.04
Output  | 0.00010028 | 0.00010028 | 0.00010028 |   0.0 |  0.00
Modify  | 0.3027     | 0.3027     | 0.3027     |   0.0 |  0.27
Other   |            | 0.04623    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5709.00 ave        5709 max        5709 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:      223008.0 ave      223008 max      223008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223008
Ave neighs/atom = 55.752000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.5736374904, Press = 0.0946050768315367
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13150.205   -13150.205   -13293.596   -13293.596     277.3992     277.3992    67260.193    67260.193    279.49738    279.49738 
   27000   -13151.653   -13151.653   -13295.043   -13295.043    277.39855    277.39855    67272.082    67272.082   -20.299319   -20.299319 
Loop time of 113.843 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.623 hours/ns, 8.784 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.45     | 113.45     | 113.45     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047441   | 0.047441   | 0.047441   |   0.0 |  0.04
Output  | 0.00010308 | 0.00010308 | 0.00010308 |   0.0 |  0.00
Modify  | 0.30145    | 0.30145    | 0.30145    |   0.0 |  0.26
Other   |            | 0.04592    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5725.00 ave        5725 max        5725 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:      223236.0 ave      223236 max      223236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223236
Ave neighs/atom = 55.809000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.560626670259, Press = -0.345492061313048
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13151.653   -13151.653   -13295.043   -13295.043    277.39855    277.39855    67272.082    67272.082   -20.299319   -20.299319 
   28000   -13157.276   -13157.276   -13297.189   -13297.189    270.67001    270.67001    67274.334    67274.334   -131.76623   -131.76623 
Loop time of 113.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.628 hours/ns, 8.783 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    | 113.47     | 113.47     | 113.47     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047564   | 0.047564   | 0.047564   |   0.0 |  0.04
Output  | 9.9864e-05 | 9.9864e-05 | 9.9864e-05 |   0.0 |  0.00
Modify  | 0.30095    | 0.30095    | 0.30095    |   0.0 |  0.26
Other   |            | 0.04548    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5739.00 ave        5739 max        5739 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:      223102.0 ave      223102 max      223102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223102
Ave neighs/atom = 55.775500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.492425945979, Press = -0.485609143856061
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13157.276   -13157.276   -13297.189   -13297.189    270.67001    270.67001    67274.334    67274.334   -131.76623   -131.76623 
   29000   -13154.168   -13154.168   -13295.226   -13295.226    272.88791    272.88791    67270.556    67270.556   -65.291368   -65.291368 
Loop time of 113.755 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.760 ns/day, 31.599 hours/ns, 8.791 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    | 113.36     | 113.36     | 113.36     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047461   | 0.047461   | 0.047461   |   0.0 |  0.04
Output  | 0.00010189 | 0.00010189 | 0.00010189 |   0.0 |  0.00
Modify  | 0.3024     | 0.3024     | 0.3024     |   0.0 |  0.27
Other   |            | 0.0456     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      222968.0 ave      222968 max      222968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222968
Ave neighs/atom = 55.742000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.447998085576, Press = -0.285797268411158
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13154.168   -13154.168   -13295.226   -13295.226    272.88791    272.88791    67270.556    67270.556   -65.291368   -65.291368 
   30000   -13151.699   -13151.699    -13294.68    -13294.68    276.60675    276.60675    67267.824    67267.824    163.52678    163.52678 
Loop time of 114.053 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.681 hours/ns, 8.768 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    | 113.65     | 113.65     | 113.65     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047977   | 0.047977   | 0.047977   |   0.0 |  0.04
Output  | 0.00010002 | 0.00010002 | 0.00010002 |   0.0 |  0.00
Modify  | 0.30353    | 0.30353    | 0.30353    |   0.0 |  0.27
Other   |            | 0.04605    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5730.00 ave        5730 max        5730 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:      223032.0 ave      223032 max      223032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223032
Ave neighs/atom = 55.758000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.393146142669, Press = 0.190667317666508
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13151.699   -13151.699    -13294.68    -13294.68    276.60675    276.60675    67267.824    67267.824    163.52678    163.52678 
   31000   -13153.918   -13153.918    -13296.26    -13296.26    275.36986    275.36986    67203.106    67203.106    696.54214    696.54214 
Loop time of 114.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.673 hours/ns, 8.770 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    | 113.63     | 113.63     | 113.63     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047624   | 0.047624   | 0.047624   |   0.0 |  0.04
Output  | 9.9176e-05 | 9.9176e-05 | 9.9176e-05 |   0.0 |  0.00
Modify  | 0.30204    | 0.30204    | 0.30204    |   0.0 |  0.26
Other   |            | 0.04521    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      223032.0 ave      223032 max      223032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223032
Ave neighs/atom = 55.758000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.380545312687, Press = 0.0445695710718558
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13153.918   -13153.918    -13296.26    -13296.26    275.36986    275.36986    67203.106    67203.106    696.54214    696.54214 
   32000   -13154.591   -13154.591   -13295.585   -13295.585    272.76254    272.76254    67156.322    67156.322     1174.089     1174.089 
Loop time of 114.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.695 hours/ns, 8.764 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    | 113.71     | 113.71     | 113.71     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047704   | 0.047704   | 0.047704   |   0.0 |  0.04
Output  | 0.00021035 | 0.00021035 | 0.00021035 |   0.0 |  0.00
Modify  | 0.29963    | 0.29963    | 0.29963    |   0.0 |  0.26
Other   |            | 0.04481    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5752.00 ave        5752 max        5752 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:      223250.0 ave      223250 max      223250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223250
Ave neighs/atom = 55.812500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.34165467921, Press = -0.724866553949933
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13154.591   -13154.591   -13295.585   -13295.585    272.76254    272.76254    67156.322    67156.322     1174.089     1174.089 
   33000   -13153.391   -13153.391   -13295.022   -13295.022    273.99545    273.99545    67191.838    67191.838    869.06222    869.06222 
Loop time of 114.116 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.699 hours/ns, 8.763 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.72     | 113.72     | 113.72     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047925   | 0.047925   | 0.047925   |   0.0 |  0.04
Output  | 0.00010335 | 0.00010335 | 0.00010335 |   0.0 |  0.00
Modify  | 0.30369    | 0.30369    | 0.30369    |   0.0 |  0.27
Other   |            | 0.04623    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5727.00 ave        5727 max        5727 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:      223510.0 ave      223510 max      223510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223510
Ave neighs/atom = 55.877500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.375215442685, Press = -1.4171544699165
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13153.391   -13153.391   -13295.022   -13295.022    273.99545    273.99545    67191.838    67191.838    869.06222    869.06222 
   34000   -13152.046   -13152.046   -13295.418   -13295.418    277.36436    277.36436    67259.508    67259.508    156.67353    156.67353 
Loop time of 114.25 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.736 hours/ns, 8.753 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    | 113.84     | 113.84     | 113.84     |   0.0 | 99.64
Neigh   | 0.018424   | 0.018424   | 0.018424   |   0.0 |  0.02
Comm    | 0.050917   | 0.050917   | 0.050917   |   0.0 |  0.04
Output  | 0.00010459 | 0.00010459 | 0.00010459 |   0.0 |  0.00
Modify  | 0.29836    | 0.29836    | 0.29836    |   0.0 |  0.26
Other   |            | 0.04383    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5744.00 ave        5744 max        5744 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:      223086.0 ave      223086 max      223086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223086
Ave neighs/atom = 55.771500
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.398927707294, Press = -1.01926322667946
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13152.046   -13152.046   -13295.418   -13295.418    277.36436    277.36436    67259.508    67259.508    156.67353    156.67353 
   35000   -13155.588   -13155.588   -13296.458   -13296.458    272.52351    272.52351    67260.567    67260.567      72.9645      72.9645 
Loop time of 113.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.650 hours/ns, 8.777 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    | 113.55     | 113.55     | 113.55     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047478   | 0.047478   | 0.047478   |   0.0 |  0.04
Output  | 0.00011448 | 0.00011448 | 0.00011448 |   0.0 |  0.00
Modify  | 0.29876    | 0.29876    | 0.29876    |   0.0 |  0.26
Other   |            | 0.04382    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5713.00 ave        5713 max        5713 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:      223098.0 ave      223098 max      223098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223098
Ave neighs/atom = 55.774500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.452380760845, Press = -0.922660172648351
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13155.588   -13155.588   -13296.458   -13296.458    272.52351    272.52351    67260.567    67260.567      72.9645      72.9645 
   36000   -13150.479   -13150.479    -13293.54    -13293.54    276.76053    276.76053    67288.005    67288.005   -84.017835   -84.017835 
Loop time of 114.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.704 hours/ns, 8.761 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    | 113.74     | 113.74     | 113.74     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047526   | 0.047526   | 0.047526   |   0.0 |  0.04
Output  | 0.00010172 | 0.00010172 | 0.00010172 |   0.0 |  0.00
Modify  | 0.30116    | 0.30116    | 0.30116    |   0.0 |  0.26
Other   |            | 0.04497    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      223080.0 ave      223080 max      223080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223080
Ave neighs/atom = 55.770000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.467058499418, Press = -0.862072573690763
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13150.479   -13150.479    -13293.54    -13293.54    276.76053    276.76053    67288.005    67288.005   -84.017835   -84.017835 
   37000    -13156.05    -13156.05   -13296.463   -13296.463    271.63967    271.63967    67319.756    67319.756   -620.13149   -620.13149 
Loop time of 114.13 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.703 hours/ns, 8.762 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.73     | 113.73     | 113.73     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047333   | 0.047333   | 0.047333   |   0.0 |  0.04
Output  | 0.0001079  | 0.0001079  | 0.0001079  |   0.0 |  0.00
Modify  | 0.30289    | 0.30289    | 0.30289    |   0.0 |  0.27
Other   |            | 0.04626    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5683.00 ave        5683 max        5683 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:      223076.0 ave      223076 max      223076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223076
Ave neighs/atom = 55.769000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.501851739845, Press = -0.820673077085417
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    -13156.05    -13156.05   -13296.463   -13296.463    271.63967    271.63967    67319.756    67319.756   -620.13149   -620.13149 
   38000   -13148.761   -13148.761   -13294.697   -13294.697    282.32133    282.32133    67409.815    67409.815   -1348.9579   -1348.9579 
Loop time of 120.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.715 ns/day, 33.585 hours/ns, 8.271 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    | 120.49     | 120.49     | 120.49     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050159   | 0.050159   | 0.050159   |   0.0 |  0.04
Output  | 0.0001018  | 0.0001018  | 0.0001018  |   0.0 |  0.00
Modify  | 0.31794    | 0.31794    | 0.31794    |   0.0 |  0.26
Other   |            | 0.04806    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5715.00 ave        5715 max        5715 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:      222966.0 ave      222966 max      222966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222966
Ave neighs/atom = 55.741500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.542758409548, Press = -0.23090544968509
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13148.761   -13148.761   -13294.697   -13294.697    282.32133    282.32133    67409.815    67409.815   -1348.9579   -1348.9579 
   39000   -13158.165   -13158.165   -13297.006   -13297.006    268.59674    268.59674    67316.948    67316.948   -598.80293   -598.80293 
Loop time of 119.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.722 ns/day, 33.231 hours/ns, 8.359 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    | 119.22     | 119.22     | 119.22     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049871   | 0.049871   | 0.049871   |   0.0 |  0.04
Output  | 0.00010269 | 0.00010269 | 0.00010269 |   0.0 |  0.00
Modify  | 0.31574    | 0.31574    | 0.31574    |   0.0 |  0.26
Other   |            | 0.04795    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5700.00 ave        5700 max        5700 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:      222626.0 ave      222626 max      222626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222626
Ave neighs/atom = 55.656500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.542696685592, Press = 0.469407413698285
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13158.165   -13158.165   -13297.006   -13297.006    268.59674    268.59674    67316.948    67316.948   -598.80293   -598.80293 
   40000   -13152.104   -13152.104   -13293.246   -13293.246    273.04843    273.04843    67262.656    67262.656    186.17071    186.17071 
Loop time of 115.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 31.984 hours/ns, 8.685 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.75     | 114.75     | 114.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048357   | 0.048357   | 0.048357   |   0.0 |  0.04
Output  | 8.7122e-05 | 8.7122e-05 | 8.7122e-05 |   0.0 |  0.00
Modify  | 0.30371    | 0.30371    | 0.30371    |   0.0 |  0.26
Other   |            | 0.04607    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5772.00 ave        5772 max        5772 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:      222756.0 ave      222756 max      222756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222756
Ave neighs/atom = 55.689000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.515352066528, Press = 0.182351728804587
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13152.104   -13152.104   -13293.246   -13293.246    273.04843    273.04843    67262.656    67262.656    186.17071    186.17071 
   41000   -13153.482   -13153.482   -13295.937   -13295.937     275.5877     275.5877    67242.313    67242.313    308.14021    308.14021 
Loop time of 113.962 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.656 hours/ns, 8.775 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    | 113.57     | 113.57     | 113.57     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047165   | 0.047165   | 0.047165   |   0.0 |  0.04
Output  | 0.00010034 | 0.00010034 | 0.00010034 |   0.0 |  0.00
Modify  | 0.30147    | 0.30147    | 0.30147    |   0.0 |  0.26
Other   |            | 0.0459     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5679.00 ave        5679 max        5679 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:      223434.0 ave      223434 max      223434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223434
Ave neighs/atom = 55.858500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.494455822769, Press = -0.28766166596156
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13153.482   -13153.482   -13295.937   -13295.937     275.5877     275.5877    67242.313    67242.313    308.14021    308.14021 
   42000   -13153.879   -13153.879   -13294.753   -13294.753    272.53114    272.53114    67225.589    67225.589    453.18397    453.18397 
Loop time of 122.68 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.704 ns/day, 34.078 hours/ns, 8.151 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    | 122.26     | 122.26     | 122.26     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050801   | 0.050801   | 0.050801   |   0.0 |  0.04
Output  | 0.00010072 | 0.00010072 | 0.00010072 |   0.0 |  0.00
Modify  | 0.32418    | 0.32418    | 0.32418    |   0.0 |  0.26
Other   |            | 0.04855    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5712.00 ave        5712 max        5712 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:      223042.0 ave      223042 max      223042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223042
Ave neighs/atom = 55.760500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.467645363058, Press = -0.444523296441064
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13153.879   -13153.879   -13294.753   -13294.753    272.53114    272.53114    67225.589    67225.589    453.18397    453.18397 
   43000   -13159.196   -13159.196   -13295.979   -13295.979    264.61519    264.61519    67158.434    67158.434    1062.0903    1062.0903 
Loop time of 119.107 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.725 ns/day, 33.085 hours/ns, 8.396 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    | 118.69     | 118.69     | 118.69     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049534   | 0.049534   | 0.049534   |   0.0 |  0.04
Output  | 0.00010394 | 0.00010394 | 0.00010394 |   0.0 |  0.00
Modify  | 0.31571    | 0.31571    | 0.31571    |   0.0 |  0.27
Other   |            | 0.04802    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5689.00 ave        5689 max        5689 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:      223494.0 ave      223494 max      223494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223494
Ave neighs/atom = 55.873500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.433838758507, Press = -1.20103765077865
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13159.196   -13159.196   -13295.979   -13295.979    264.61519    264.61519    67158.434    67158.434    1062.0903    1062.0903 
   44000   -13152.117   -13152.117   -13294.094   -13294.094    274.66431    274.66431    67264.052    67264.052     148.6927     148.6927 
Loop time of 113.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.630 hours/ns, 8.782 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    | 113.47     | 113.47     | 113.47     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047996   | 0.047996   | 0.047996   |   0.0 |  0.04
Output  | 9.6952e-05 | 9.6952e-05 | 9.6952e-05 |   0.0 |  0.00
Modify  | 0.30273    | 0.30273    | 0.30273    |   0.0 |  0.27
Other   |            | 0.04656    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5738.00 ave        5738 max        5738 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:      223522.0 ave      223522 max      223522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223522
Ave neighs/atom = 55.880500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.39995791092, Press = -1.67687088532206
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13152.117   -13152.117   -13294.094   -13294.094    274.66431    274.66431    67264.052    67264.052     148.6927     148.6927 
   45000   -13154.966   -13154.966   -13295.562   -13295.562    271.99119    271.99119    67292.426    67292.426   -179.12026   -179.12026 
Loop time of 113.892 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.637 hours/ns, 8.780 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    | 113.5      | 113.5      | 113.5      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047276   | 0.047276   | 0.047276   |   0.0 |  0.04
Output  | 0.00010937 | 0.00010937 | 0.00010937 |   0.0 |  0.00
Modify  | 0.30066    | 0.30066    | 0.30066    |   0.0 |  0.26
Other   |            | 0.04442    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5702.00 ave        5702 max        5702 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:      223384.0 ave      223384 max      223384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223384
Ave neighs/atom = 55.846000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.394063182534, Press = -0.9341401963929
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13154.966   -13154.966   -13295.562   -13295.562    271.99119    271.99119    67292.426    67292.426   -179.12026   -179.12026 
   46000   -13151.931   -13151.931   -13292.927   -13292.927    272.76662    272.76662    67317.554    67317.554   -317.76954   -317.76954 
Loop time of 113.596 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.761 ns/day, 31.554 hours/ns, 8.803 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    | 113.21     | 113.21     | 113.21     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047536   | 0.047536   | 0.047536   |   0.0 |  0.04
Output  | 0.00010403 | 0.00010403 | 0.00010403 |   0.0 |  0.00
Modify  | 0.29856    | 0.29856    | 0.29856    |   0.0 |  0.26
Other   |            | 0.04366    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5739.00 ave        5739 max        5739 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:      222898.0 ave      222898 max      222898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222898
Ave neighs/atom = 55.724500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.429001343736, Press = -0.623036784667508
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13151.931   -13151.931   -13292.927   -13292.927    272.76662    272.76662    67317.554    67317.554   -317.76954   -317.76954 
   47000   -13154.778   -13154.778   -13295.963   -13295.963    273.13238    273.13238    67320.553    67320.553   -501.70823   -501.70823 
Loop time of 113.888 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.635 hours/ns, 8.781 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    | 113.49     | 113.49     | 113.49     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047007   | 0.047007   | 0.047007   |   0.0 |  0.04
Output  | 9.9394e-05 | 9.9394e-05 | 9.9394e-05 |   0.0 |  0.00
Modify  | 0.30135    | 0.30135    | 0.30135    |   0.0 |  0.26
Other   |            | 0.0458     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5688.00 ave        5688 max        5688 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:      222956.0 ave      222956 max      222956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222956
Ave neighs/atom = 55.739000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.448345165948, Press = -0.358837302801664
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13154.778   -13154.778   -13295.963   -13295.963    273.13238    273.13238    67320.553    67320.553   -501.70823   -501.70823 
   48000     -13152.5     -13152.5   -13290.965   -13290.965    267.86822    267.86822    67332.154    67332.154   -490.02598   -490.02598 
Loop time of 113.924 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.646 hours/ns, 8.778 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    | 113.53     | 113.53     | 113.53     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047655   | 0.047655   | 0.047655   |   0.0 |  0.04
Output  | 9.9907e-05 | 9.9907e-05 | 9.9907e-05 |   0.0 |  0.00
Modify  | 0.30011    | 0.30011    | 0.30011    |   0.0 |  0.26
Other   |            | 0.04518    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5723.00 ave        5723 max        5723 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:      222774.0 ave      222774 max      222774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222774
Ave neighs/atom = 55.693500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.442171786885, Press = -0.190521688891256
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000     -13152.5     -13152.5   -13290.965   -13290.965    267.86822    267.86822    67332.154    67332.154   -490.02598   -490.02598 
   49000   -13155.844   -13155.844   -13295.872   -13295.872    270.89354    270.89354    67327.938    67327.938   -599.10745   -599.10745 
Loop time of 114.057 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.682 hours/ns, 8.768 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    | 113.66     | 113.66     | 113.66     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047582   | 0.047582   | 0.047582   |   0.0 |  0.04
Output  | 0.00011737 | 0.00011737 | 0.00011737 |   0.0 |  0.00
Modify  | 0.30064    | 0.30064    | 0.30064    |   0.0 |  0.26
Other   |            | 0.04431    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5690.00 ave        5690 max        5690 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:      223246.0 ave      223246 max      223246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223246
Ave neighs/atom = 55.811500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.427893329442, Press = 0.717871046907459
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13155.844   -13155.844   -13295.872   -13295.872    270.89354    270.89354    67327.938    67327.938   -599.10745   -599.10745 
   50000    -13152.95    -13152.95    -13296.12    -13296.12    276.97113    276.97113    67243.009    67243.009    394.34565    394.34565 
Loop time of 115.807 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.746 ns/day, 32.169 hours/ns, 8.635 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    | 115.41     | 115.41     | 115.41     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048451   | 0.048451   | 0.048451   |   0.0 |  0.04
Output  | 9.7357e-05 | 9.7357e-05 | 9.7357e-05 |   0.0 |  0.00
Modify  | 0.30532    | 0.30532    | 0.30532    |   0.0 |  0.26
Other   |            | 0.0456     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5735.00 ave        5735 max        5735 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:      222668.0 ave      222668 max      222668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222668
Ave neighs/atom = 55.667000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.428758594545, Press = 0.684417286562976
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -13152.95    -13152.95    -13296.12    -13296.12    276.97113    276.97113    67243.009    67243.009    394.34565    394.34565 
   51000   -13154.942   -13154.942   -13296.549   -13296.549    273.94812    273.94812    67197.141    67197.141    749.60101    749.60101 
Loop time of 117.593 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.735 ns/day, 32.665 hours/ns, 8.504 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    | 117.18     | 117.18     | 117.18     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049501   | 0.049501   | 0.049501   |   0.0 |  0.04
Output  | 0.00010637 | 0.00010637 | 0.00010637 |   0.0 |  0.00
Modify  | 0.31222    | 0.31222    | 0.31222    |   0.0 |  0.27
Other   |            | 0.04714    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5740.00 ave        5740 max        5740 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:      222784.0 ave      222784 max      222784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222784
Ave neighs/atom = 55.696000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.432733519483, Press = 0.000379892273511048
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13154.942   -13154.942   -13296.549   -13296.549    273.94812    273.94812    67197.141    67197.141    749.60101    749.60101 
   52000   -13150.548   -13150.548   -13291.356   -13291.356    272.40346    272.40346    67229.128    67229.128    634.34836    634.34836 
Loop time of 113.896 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.638 hours/ns, 8.780 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    | 113.5      | 113.5      | 113.5      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047675   | 0.047675   | 0.047675   |   0.0 |  0.04
Output  | 0.0001244  | 0.0001244  | 0.0001244  |   0.0 |  0.00
Modify  | 0.29996    | 0.29996    | 0.29996    |   0.0 |  0.26
Other   |            | 0.0444     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5731.00 ave        5731 max        5731 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:      223092.0 ave      223092 max      223092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223092
Ave neighs/atom = 55.773000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.461702720983, Press = -0.436830420120319
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13150.548   -13150.548   -13291.356   -13291.356    272.40346    272.40346    67229.128    67229.128    634.34836    634.34836 
   53000   -13156.561   -13156.561   -13297.821   -13297.821    273.27699    273.27699    67241.664    67241.664    204.64141    204.64141 
Loop time of 114.086 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.691 hours/ns, 8.765 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    | 113.69     | 113.69     | 113.69     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047567   | 0.047567   | 0.047567   |   0.0 |  0.04
Output  | 9.8917e-05 | 9.8917e-05 | 9.8917e-05 |   0.0 |  0.00
Modify  | 0.30317    | 0.30317    | 0.30317    |   0.0 |  0.27
Other   |            | 0.04562    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      223460.0 ave      223460 max      223460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223460
Ave neighs/atom = 55.865000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.463692850889, Press = -0.60659637230028
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13156.561   -13156.561   -13297.821   -13297.821    273.27699    273.27699    67241.664    67241.664    204.64141    204.64141 
   54000   -13150.961   -13150.961   -13295.771   -13295.771    280.14328    280.14328     67297.95     67297.95   -204.26638   -204.26638 
Loop time of 113.961 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.656 hours/ns, 8.775 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    | 113.57     | 113.57     | 113.57     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047466   | 0.047466   | 0.047466   |   0.0 |  0.04
Output  | 0.00010666 | 0.00010666 | 0.00010666 |   0.0 |  0.00
Modify  | 0.29987    | 0.29987    | 0.29987    |   0.0 |  0.26
Other   |            | 0.04466    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5720.00 ave        5720 max        5720 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:      222958.0 ave      222958 max      222958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222958
Ave neighs/atom = 55.739500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.473524445428, Press = -0.557867864449254
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13150.961   -13150.961   -13295.771   -13295.771    280.14328    280.14328     67297.95     67297.95   -204.26638   -204.26638 
   55000   -13154.554   -13154.554   -13293.804   -13293.804    269.38674    269.38674    67302.787    67302.787   -306.25178   -306.25178 
Loop time of 117.085 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.738 ns/day, 32.524 hours/ns, 8.541 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    | 116.68     | 116.68     | 116.68     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049093   | 0.049093   | 0.049093   |   0.0 |  0.04
Output  | 9.9454e-05 | 9.9454e-05 | 9.9454e-05 |   0.0 |  0.00
Modify  | 0.31155    | 0.31155    | 0.31155    |   0.0 |  0.27
Other   |            | 0.04728    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5726.00 ave        5726 max        5726 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:      222698.0 ave      222698 max      222698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222698
Ave neighs/atom = 55.674500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.465172840193, Press = -0.530528508391243
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13154.554   -13154.554   -13293.804   -13293.804    269.38674    269.38674    67302.787    67302.787   -306.25178   -306.25178 
   56000   -13154.196   -13154.196   -13293.261   -13293.261    269.03181    269.03181     67321.84     67321.84   -489.89737   -489.89737 
Loop time of 113.892 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.637 hours/ns, 8.780 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    | 113.5      | 113.5      | 113.5      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047076   | 0.047076   | 0.047076   |   0.0 |  0.04
Output  | 9.7996e-05 | 9.7996e-05 | 9.7996e-05 |   0.0 |  0.00
Modify  | 0.29846    | 0.29846    | 0.29846    |   0.0 |  0.26
Other   |            | 0.04393    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5706.00 ave        5706 max        5706 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:      222864.0 ave      222864 max      222864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222864
Ave neighs/atom = 55.716000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.453013700107, Press = -0.491568326331183
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -13154.196   -13154.196   -13293.261   -13293.261    269.03181    269.03181     67321.84     67321.84   -489.89737   -489.89737 
   57000   -13156.211   -13156.211   -13296.723   -13296.723    271.82996    271.82996    67356.017    67356.017   -968.62394   -968.62394 
Loop time of 122.236 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.707 ns/day, 33.955 hours/ns, 8.181 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    | 121.82     | 121.82     | 121.82     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050323   | 0.050323   | 0.050323   |   0.0 |  0.04
Output  | 0.00010129 | 0.00010129 | 0.00010129 |   0.0 |  0.00
Modify  | 0.32053    | 0.32053    | 0.32053    |   0.0 |  0.26
Other   |            | 0.04682    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5679.00 ave        5679 max        5679 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:      223298.0 ave      223298 max      223298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223298
Ave neighs/atom = 55.824500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.466748343777, Press = -0.295351143276599
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13156.211   -13156.211   -13296.723   -13296.723    271.82996    271.82996    67356.017    67356.017   -968.62394   -968.62394 
   58000   -13151.299   -13151.299   -13294.117   -13294.117    276.29193    276.29193    67372.511    67372.511   -965.97487   -965.97487 
Loop time of 113.774 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.604 hours/ns, 8.789 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    | 113.38     | 113.38     | 113.38     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047418   | 0.047418   | 0.047418   |   0.0 |  0.04
Output  | 0.00010977 | 0.00010977 | 0.00010977 |   0.0 |  0.00
Modify  | 0.3008     | 0.3008     | 0.3008     |   0.0 |  0.26
Other   |            | 0.04524    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5721.00 ave        5721 max        5721 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:      222622.0 ave      222622 max      222622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222622
Ave neighs/atom = 55.655500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.478826088172, Press = 0.347291620678065
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -13151.299   -13151.299   -13294.117   -13294.117    276.29193    276.29193    67372.511    67372.511   -965.97487   -965.97487 
   59000   -13156.687   -13156.687   -13296.936   -13296.936    271.32175    271.32175     67274.77     67274.77   -204.91903   -204.91903 
Loop time of 136.546 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.633 ns/day, 37.929 hours/ns, 7.324 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    | 136.07     | 136.07     | 136.07     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056572   | 0.056572   | 0.056572   |   0.0 |  0.04
Output  | 9.9621e-05 | 9.9621e-05 | 9.9621e-05 |   0.0 |  0.00
Modify  | 0.36098    | 0.36098    | 0.36098    |   0.0 |  0.26
Other   |            | 0.05409    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5729.00 ave        5729 max        5729 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:      222764.0 ave      222764 max      222764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222764
Ave neighs/atom = 55.691000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.482160399952, Press = 0.407832192914827
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -13156.687   -13156.687   -13296.936   -13296.936    271.32175    271.32175     67274.77     67274.77   -204.91903   -204.91903 
   60000   -13156.264   -13156.264   -13298.231   -13298.231    274.64593    274.64593    67223.854    67223.854    421.21162    421.21162 
Loop time of 113.961 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.656 hours/ns, 8.775 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    | 113.57     | 113.57     | 113.57     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047353   | 0.047353   | 0.047353   |   0.0 |  0.04
Output  | 9.9449e-05 | 9.9449e-05 | 9.9449e-05 |   0.0 |  0.00
Modify  | 0.30136    | 0.30136    | 0.30136    |   0.0 |  0.26
Other   |            | 0.04705    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      222810.0 ave      222810 max      222810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222810
Ave neighs/atom = 55.702500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.488701665846, Press = -0.00408767471205171
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -13156.264   -13156.264   -13298.231   -13298.231    274.64593    274.64593    67223.854    67223.854    421.21162    421.21162 
   61000   -13151.028   -13151.028   -13294.776   -13294.776    278.09008    278.09008    67211.396    67211.396    728.82471    728.82471 
Loop time of 113.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.652 hours/ns, 8.776 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    | 113.55     | 113.55     | 113.55     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047209   | 0.047209   | 0.047209   |   0.0 |  0.04
Output  | 0.0001023  | 0.0001023  | 0.0001023  |   0.0 |  0.00
Modify  | 0.30152    | 0.30152    | 0.30152    |   0.0 |  0.26
Other   |            | 0.04684    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5703.00 ave        5703 max        5703 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:      222926.0 ave      222926 max      222926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222926
Ave neighs/atom = 55.731500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.49957944753, Press = -0.18545228138279
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -13151.028   -13151.028   -13294.776   -13294.776    278.09008    278.09008    67211.396    67211.396    728.82471    728.82471 
   62000   -13154.927   -13154.927   -13294.077   -13294.077    269.19494    269.19494    67196.134    67196.134    779.76822    779.76822 
Loop time of 118.655 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.728 ns/day, 32.960 hours/ns, 8.428 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    | 118.24     | 118.24     | 118.24     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049467   | 0.049467   | 0.049467   |   0.0 |  0.04
Output  | 0.00020977 | 0.00020977 | 0.00020977 |   0.0 |  0.00
Modify  | 0.31412    | 0.31412    | 0.31412    |   0.0 |  0.26
Other   |            | 0.04864    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5718.00 ave        5718 max        5718 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:      223148.0 ave      223148 max      223148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223148
Ave neighs/atom = 55.787000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.488081372637, Press = -0.498991288153263
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -13154.927   -13154.927   -13294.077   -13294.077    269.19494    269.19494    67196.134    67196.134    779.76822    779.76822 
   63000    -13156.03    -13156.03   -13295.878   -13295.878    270.54491    270.54491    67240.107    67240.107    255.15992    255.15992 
Loop time of 114.265 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.740 hours/ns, 8.752 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.87     | 113.87     | 113.87     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047549   | 0.047549   | 0.047549   |   0.0 |  0.04
Output  | 0.00010185 | 0.00010185 | 0.00010185 |   0.0 |  0.00
Modify  | 0.30285    | 0.30285    | 0.30285    |   0.0 |  0.27
Other   |            | 0.04627    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5704.00 ave        5704 max        5704 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:      223704.0 ave      223704 max      223704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223704
Ave neighs/atom = 55.926000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.476980718445, Press = -0.689308510039651
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000    -13156.03    -13156.03   -13295.878   -13295.878    270.54491    270.54491    67240.107    67240.107    255.15992    255.15992 
   64000   -13150.827   -13150.827   -13293.295   -13293.295    275.61494    275.61494    67353.837    67353.837   -689.18337   -689.18337 
Loop time of 118.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.728 ns/day, 32.980 hours/ns, 8.423 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    | 118.32     | 118.32     | 118.32     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049243   | 0.049243   | 0.049243   |   0.0 |  0.04
Output  | 9.9688e-05 | 9.9688e-05 | 9.9688e-05 |   0.0 |  0.00
Modify  | 0.31296    | 0.31296    | 0.31296    |   0.0 |  0.26
Other   |            | 0.04756    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5705.00 ave        5705 max        5705 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:      222930.0 ave      222930 max      222930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222930
Ave neighs/atom = 55.732500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.452486268663, Press = -1.03448187103542
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -13150.827   -13150.827   -13293.295   -13293.295    275.61494    275.61494    67353.837    67353.837   -689.18337   -689.18337 
   65000   -13155.124   -13155.124   -13293.967   -13293.967    268.60283    268.60283    67367.418    67367.418   -942.93248   -942.93248 
Loop time of 118.387 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.730 ns/day, 32.885 hours/ns, 8.447 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    | 117.97     | 117.97     | 117.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04957    | 0.04957    | 0.04957    |   0.0 |  0.04
Output  | 0.00010291 | 0.00010291 | 0.00010291 |   0.0 |  0.00
Modify  | 0.31535    | 0.31535    | 0.31535    |   0.0 |  0.27
Other   |            | 0.0494     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5717.00 ave        5717 max        5717 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:      222836.0 ave      222836 max      222836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222836
Ave neighs/atom = 55.709000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.453240550201, Press = -0.457587524528551
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -13155.124   -13155.124   -13293.967   -13293.967    268.60283    268.60283    67367.418    67367.418   -942.93248   -942.93248 
   66000   -13150.998   -13150.998   -13294.075   -13294.075    276.79072    276.79072    67313.203    67313.203   -340.96778   -340.96778 
Loop time of 115.231 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 32.009 hours/ns, 8.678 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    | 114.83     | 114.83     | 114.83     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048125   | 0.048125   | 0.048125   |   0.0 |  0.04
Output  | 0.00010231 | 0.00010231 | 0.00010231 |   0.0 |  0.00
Modify  | 0.30477    | 0.30477    | 0.30477    |   0.0 |  0.26
Other   |            | 0.04663    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5694.00 ave        5694 max        5694 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:      222894.0 ave      222894 max      222894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222894
Ave neighs/atom = 55.723500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.475789788765, Press = -0.151426043603088
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -13150.998   -13150.998   -13294.075   -13294.075    276.79072    276.79072    67313.203    67313.203   -340.96778   -340.96778 
   67000   -13154.303   -13154.303    -13295.36    -13295.36    272.88328    272.88328    67290.632    67290.632    -231.0006    -231.0006 
Loop time of 132.85 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.650 ns/day, 36.903 hours/ns, 7.527 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    | 132.39     | 132.39     | 132.39     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054899   | 0.054899   | 0.054899   |   0.0 |  0.04
Output  | 0.00021369 | 0.00021369 | 0.00021369 |   0.0 |  0.00
Modify  | 0.35249    | 0.35249    | 0.35249    |   0.0 |  0.27
Other   |            | 0.05338    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5688.00 ave        5688 max        5688 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:      223028.0 ave      223028 max      223028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223028
Ave neighs/atom = 55.757000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.478642386931, Press = -0.0444240780118392
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -13154.303   -13154.303    -13295.36    -13295.36    272.88328    272.88328    67290.632    67290.632    -231.0006    -231.0006 
   68000   -13154.055   -13154.055   -13295.575   -13295.575    273.78064    273.78064    67283.855    67283.855   -151.35091   -151.35091 
Loop time of 154.736 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.558 ns/day, 42.982 hours/ns, 6.463 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    | 154.19     | 154.19     | 154.19     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065607   | 0.065607   | 0.065607   |   0.0 |  0.04
Output  | 0.00035303 | 0.00035303 | 0.00035303 |   0.0 |  0.00
Modify  | 0.41511    | 0.41511    | 0.41511    |   0.0 |  0.27
Other   |            | 0.06355    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5681.00 ave        5681 max        5681 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:      223078.0 ave      223078 max      223078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223078
Ave neighs/atom = 55.769500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.503318107862, Press = 0.0101885731106313
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -13154.055   -13154.055   -13295.575   -13295.575    273.78064    273.78064    67283.855    67283.855   -151.35091   -151.35091 
   69000   -13151.207   -13151.207   -13292.841   -13292.841    274.00217    274.00217    67246.033    67246.033    396.03885    396.03885 
Loop time of 222.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.852 hours/ns, 4.491 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    | 221.92     | 221.92     | 221.92     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093337   | 0.093337   | 0.093337   |   0.0 |  0.04
Output  | 0.00030927 | 0.00030927 | 0.00030927 |   0.0 |  0.00
Modify  | 0.577      | 0.577      | 0.577      |   0.0 |  0.26
Other   |            | 0.08026    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5709.00 ave        5709 max        5709 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:      223172.0 ave      223172 max      223172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223172
Ave neighs/atom = 55.793000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.498818308881, Press = 0.464763126834414
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -13151.207   -13151.207   -13292.841   -13292.841    274.00217    274.00217    67246.033    67246.033    396.03885    396.03885 
   70000   -13155.377   -13155.377   -13297.549   -13297.549    275.03997    275.03997    67172.712    67172.712    1001.2765    1001.2765 
Loop time of 197.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.929 hours/ns, 5.057 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    | 197.07     | 197.07     | 197.07     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081377   | 0.081377   | 0.081377   |   0.0 |  0.04
Output  | 0.00021906 | 0.00021906 | 0.00021906 |   0.0 |  0.00
Modify  | 0.51511    | 0.51511    | 0.51511    |   0.0 |  0.26
Other   |            | 0.07319    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5687.00 ave        5687 max        5687 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:      223238.0 ave      223238 max      223238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223238
Ave neighs/atom = 55.809500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.511972835701, Press = -0.017638341555172
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -13155.377   -13155.377   -13297.549   -13297.549    275.03997    275.03997    67172.712    67172.712    1001.2765    1001.2765 
   71000   -13151.912   -13151.912   -13295.718   -13295.718    278.20234    278.20234    67216.136    67216.136    676.11494    676.11494 
Loop time of 229.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.376 ns/day, 63.867 hours/ns, 4.349 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    | 229.16     | 229.16     | 229.16     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09397    | 0.09397    | 0.09397    |   0.0 |  0.04
Output  | 0.0001873  | 0.0001873  | 0.0001873  |   0.0 |  0.00
Modify  | 0.58917    | 0.58917    | 0.58917    |   0.0 |  0.26
Other   |            | 0.0797     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5691.00 ave        5691 max        5691 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:      223376.0 ave      223376 max      223376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223376
Ave neighs/atom = 55.844000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.488544888172, Press = -0.248032758650606
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -13151.912   -13151.912   -13295.718   -13295.718    278.20234    278.20234    67216.136    67216.136    676.11494    676.11494 
   72000   -13153.903   -13153.903    -13296.56    -13296.56     275.9791     275.9791    67228.626    67228.626     462.0741     462.0741 
Loop time of 199.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.411 hours/ns, 5.013 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    | 198.8      | 198.8      | 198.8      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083178   | 0.083178   | 0.083178   |   0.0 |  0.04
Output  | 0.00035215 | 0.00035215 | 0.00035215 |   0.0 |  0.00
Modify  | 0.52117    | 0.52117    | 0.52117    |   0.0 |  0.26
Other   |            | 0.07377    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5722.00 ave        5722 max        5722 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:      223164.0 ave      223164 max      223164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223164
Ave neighs/atom = 55.791000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.479404630471, Press = -0.471292165093968
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -13153.903   -13153.903    -13296.56    -13296.56     275.9791     275.9791    67228.626    67228.626     462.0741     462.0741 
   73000   -13149.325   -13149.325    -13292.16    -13292.16     276.3226     276.3226    67291.971    67291.971    87.202387    87.202387 
Loop time of 205.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.046 hours/ns, 4.869 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    | 204.66     | 204.66     | 204.66     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086479   | 0.086479   | 0.086479   |   0.0 |  0.04
Output  | 0.00035348 | 0.00035348 | 0.00035348 |   0.0 |  0.00
Modify  | 0.53966    | 0.53966    | 0.53966    |   0.0 |  0.26
Other   |            | 0.07851    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5715.00 ave        5715 max        5715 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:      223100.0 ave      223100 max      223100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223100
Ave neighs/atom = 55.775000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.476541914373, Press = -0.536685444320082
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -13149.325   -13149.325    -13292.16    -13292.16     276.3226     276.3226    67291.971    67291.971    87.202387    87.202387 
   74000   -13157.195   -13157.195   -13295.067   -13295.067    266.72397    266.72397    67313.296    67313.296   -486.40758   -486.40758 
Loop time of 200.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.763 hours/ns, 4.981 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    | 200.06     | 200.06     | 200.06     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084212   | 0.084212   | 0.084212   |   0.0 |  0.04
Output  | 0.00018614 | 0.00018614 | 0.00018614 |   0.0 |  0.00
Modify  | 0.52613    | 0.52613    | 0.52613    |   0.0 |  0.26
Other   |            | 0.07662    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5699.00 ave        5699 max        5699 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:      223232.0 ave      223232 max      223232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223232
Ave neighs/atom = 55.808000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.487720029299, Press = -0.69293247846044
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -13157.195   -13157.195   -13295.067   -13295.067    266.72397    266.72397    67313.296    67313.296   -486.40758   -486.40758 
   75000   -13154.105   -13154.105   -13294.658   -13294.658    271.90895    271.90895    67399.503    67399.503     -1325.57     -1325.57 
Loop time of 202.01 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.114 hours/ns, 4.950 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    | 201.32     | 201.32     | 201.32     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085228   | 0.085228   | 0.085228   |   0.0 |  0.04
Output  | 0.00036347 | 0.00036347 | 0.00036347 |   0.0 |  0.00
Modify  | 0.53045    | 0.53045    | 0.53045    |   0.0 |  0.26
Other   |            | 0.07652    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5730.00 ave        5730 max        5730 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:      222922.0 ave      222922 max      222922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222922
Ave neighs/atom = 55.730500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.496088514869, Press = -0.49460930050521
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -13154.105   -13154.105   -13294.658   -13294.658    271.90895    271.90895    67399.503    67399.503     -1325.57     -1325.57 
   76000    -13158.27    -13158.27   -13298.519   -13298.519    271.32134    271.32134    67313.769    67313.769   -604.54034   -604.54034 
Loop time of 186.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.806 hours/ns, 5.362 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    | 185.86     | 185.86     | 185.86     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078921   | 0.078921   | 0.078921   |   0.0 |  0.04
Output  | 0.00011383 | 0.00011383 | 0.00011383 |   0.0 |  0.00
Modify  | 0.49269    | 0.49269    | 0.49269    |   0.0 |  0.26
Other   |            | 0.07274    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5677.00 ave        5677 max        5677 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:      222656.0 ave      222656 max      222656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222656
Ave neighs/atom = 55.664000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.504889407855, Press = -0.0669332678213893
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000    -13158.27    -13158.27   -13298.519   -13298.519    271.32134    271.32134    67313.769    67313.769   -604.54034   -604.54034 
   77000   -13151.869   -13151.869   -13295.764   -13295.764    278.37397    278.37397    67302.568    67302.568   -263.87126   -263.87126 
Loop time of 179.988 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.480 ns/day, 49.997 hours/ns, 5.556 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    | 179.36     | 179.36     | 179.36     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077455   | 0.077455   | 0.077455   |   0.0 |  0.04
Output  | 0.00015793 | 0.00015793 | 0.00015793 |   0.0 |  0.00
Modify  | 0.47969    | 0.47969    | 0.47969    |   0.0 |  0.27
Other   |            | 0.07355    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5718.00 ave        5718 max        5718 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:      222618.0 ave      222618 max      222618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222618
Ave neighs/atom = 55.654500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.487238138823, Press = -0.0582326233461436
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -13151.869   -13151.869   -13295.764   -13295.764    278.37397    278.37397    67302.568    67302.568   -263.87126   -263.87126 
   78000   -13154.498   -13154.498   -13296.155   -13296.155      274.044      274.044     67281.85     67281.85   -174.81953   -174.81953 
Loop time of 124.037 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.697 ns/day, 34.455 hours/ns, 8.062 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    | 123.61     | 123.61     | 123.61     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052355   | 0.052355   | 0.052355   |   0.0 |  0.04
Output  | 8.5935e-05 | 8.5935e-05 | 8.5935e-05 |   0.0 |  0.00
Modify  | 0.32841    | 0.32841    | 0.32841    |   0.0 |  0.26
Other   |            | 0.04903    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5706.00 ave        5706 max        5706 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:      222950.0 ave      222950 max      222950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222950
Ave neighs/atom = 55.737500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.457157910916, Press = -0.136461299083303
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -13154.498   -13154.498   -13296.155   -13296.155      274.044      274.044     67281.85     67281.85   -174.81953   -174.81953 
   79000   -13151.265   -13151.265   -13293.501   -13293.501    275.16484    275.16484    67270.805    67270.805    135.29089    135.29089 
Loop time of 114.79 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.886 hours/ns, 8.712 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.4      | 114.4      | 114.4      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048147   | 0.048147   | 0.048147   |   0.0 |  0.04
Output  | 0.00010507 | 0.00010507 | 0.00010507 |   0.0 |  0.00
Modify  | 0.30147    | 0.30147    | 0.30147    |   0.0 |  0.26
Other   |            | 0.04399    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5720.00 ave        5720 max        5720 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:      223060.0 ave      223060 max      223060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223060
Ave neighs/atom = 55.765000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.445247510947, Press = -0.0994742326656124
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -13151.265   -13151.265   -13293.501   -13293.501    275.16484    275.16484    67270.805    67270.805    135.29089    135.29089 
   80000   -13157.122   -13157.122   -13297.999   -13297.999    272.53578    272.53578    67186.733    67186.733    742.59926    742.59926 
Loop time of 124.67 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.630 hours/ns, 8.021 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    | 124.24     | 124.24     | 124.24     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052569   | 0.052569   | 0.052569   |   0.0 |  0.04
Output  | 9.6871e-05 | 9.6871e-05 | 9.6871e-05 |   0.0 |  0.00
Modify  | 0.32796    | 0.32796    | 0.32796    |   0.0 |  0.26
Other   |            | 0.04852    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5683.00 ave        5683 max        5683 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:      223158.0 ave      223158 max      223158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223158
Ave neighs/atom = 55.789500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.445600356936, Press = -0.0148410449775839
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -13157.122   -13157.122   -13297.999   -13297.999    272.53578    272.53578    67186.733    67186.733    742.59926    742.59926 
   81000   -13149.125   -13149.125   -13293.843   -13293.843    279.96595    279.96595    67169.147    67169.147    1159.0391    1159.0391 
Loop time of 117.3 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.737 ns/day, 32.583 hours/ns, 8.525 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    | 116.9      | 116.9      | 116.9      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049284   | 0.049284   | 0.049284   |   0.0 |  0.04
Output  | 9.9238e-05 | 9.9238e-05 | 9.9238e-05 |   0.0 |  0.00
Modify  | 0.30762    | 0.30762    | 0.30762    |   0.0 |  0.26
Other   |            | 0.04475    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5724.00 ave        5724 max        5724 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:      223156.0 ave      223156 max      223156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223156
Ave neighs/atom = 55.789000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.460340506131, Press = -0.34258598371747
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -13149.125   -13149.125   -13293.843   -13293.843    279.96595    279.96595    67169.147    67169.147    1159.0391    1159.0391 
   82000   -13157.471   -13157.471   -13295.462   -13295.462    266.95298    266.95298    67222.348    67222.348    441.25241    441.25241 
Loop time of 119.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.723 ns/day, 33.208 hours/ns, 8.365 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    | 119.14     | 119.14     | 119.14     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050194   | 0.050194   | 0.050194   |   0.0 |  0.04
Output  | 9.5931e-05 | 9.5931e-05 | 9.5931e-05 |   0.0 |  0.00
Modify  | 0.31525    | 0.31525    | 0.31525    |   0.0 |  0.26
Other   |            | 0.04614    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5725.00 ave        5725 max        5725 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:      223620.0 ave      223620 max      223620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223620
Ave neighs/atom = 55.905000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.457022093042, Press = -0.570653337840253
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -13157.471   -13157.471   -13295.462   -13295.462    266.95298    266.95298    67222.348    67222.348    441.25241    441.25241 
   83000   -13154.246   -13154.246   -13296.057   -13296.057    274.34366    274.34366    67301.064    67301.064   -336.29134   -336.29134 
Loop time of 127.54 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.428 hours/ns, 7.841 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    | 127.1      | 127.1      | 127.1      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053924   | 0.053924   | 0.053924   |   0.0 |  0.04
Output  | 0.00036055 | 0.00036055 | 0.00036055 |   0.0 |  0.00
Modify  | 0.33784    | 0.33784    | 0.33784    |   0.0 |  0.26
Other   |            | 0.04984    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5688.00 ave        5688 max        5688 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:      223464.0 ave      223464 max      223464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223464
Ave neighs/atom = 55.866000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.4517728827, Press = -0.425530513148574
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -13154.246   -13154.246   -13296.057   -13296.057    274.34366    274.34366    67301.064    67301.064   -336.29134   -336.29134 
   84000   -13149.376   -13149.376   -13291.939   -13291.939    275.79744    275.79744    67333.021    67333.021   -362.46983   -362.46983 
Loop time of 178.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.484 ns/day, 49.634 hours/ns, 5.597 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    | 178.05     | 178.05     | 178.05     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07664    | 0.07664    | 0.07664    |   0.0 |  0.04
Output  | 0.00039474 | 0.00039474 | 0.00039474 |   0.0 |  0.00
Modify  | 0.48288    | 0.48288    | 0.48288    |   0.0 |  0.27
Other   |            | 0.0728     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5691.00 ave        5691 max        5691 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:      222826.0 ave      222826 max      222826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222826
Ave neighs/atom = 55.706500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.461752272331, Press = -0.250009185764525
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -13149.376   -13149.376   -13291.939   -13291.939    275.79744    275.79744    67333.021    67333.021   -362.46983   -362.46983 
   85000   -13154.642   -13154.642    -13295.78    -13295.78    273.04175    273.04175    67292.858    67292.858   -264.82179   -264.82179 
Loop time of 171.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.504 ns/day, 47.602 hours/ns, 5.835 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    | 170.75     | 170.75     | 170.75     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075926   | 0.075926   | 0.075926   |   0.0 |  0.04
Output  | 0.00010966 | 0.00010966 | 0.00010966 |   0.0 |  0.00
Modify  | 0.47099    | 0.47099    | 0.47099    |   0.0 |  0.27
Other   |            | 0.07371    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5685.00 ave        5685 max        5685 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:      223196.0 ave      223196 max      223196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223196
Ave neighs/atom = 55.799000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.457663535602, Press = -0.239172787370393
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -13154.642   -13154.642    -13295.78    -13295.78    273.04175    273.04175    67292.858    67292.858   -264.82179   -264.82179 
   86000   -13154.395   -13154.395   -13296.624   -13296.624    275.15222    275.15222    67280.831    67280.831   -118.61014   -118.61014 
Loop time of 197.15 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.764 hours/ns, 5.072 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    | 196.45     | 196.45     | 196.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085468   | 0.085468   | 0.085468   |   0.0 |  0.04
Output  | 0.00046482 | 0.00046482 | 0.00046482 |   0.0 |  0.00
Modify  | 0.5351     | 0.5351     | 0.5351     |   0.0 |  0.27
Other   |            | 0.08022    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5726.00 ave        5726 max        5726 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:      222832.0 ave      222832 max      222832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222832
Ave neighs/atom = 55.708000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.449341946768, Press = -0.208450781237962
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -13154.395   -13154.395   -13296.624   -13296.624    275.15222    275.15222    67280.831    67280.831   -118.61014   -118.61014 
   87000   -13157.475   -13157.475   -13298.106   -13298.106    272.06119    272.06119    67254.511    67254.511    12.712013    12.712013 
Loop time of 139.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.620 ns/day, 38.679 hours/ns, 7.182 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.75     | 138.75     | 138.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059938   | 0.059938   | 0.059938   |   0.0 |  0.04
Output  | 0.00026139 | 0.00026139 | 0.00026139 |   0.0 |  0.00
Modify  | 0.37432    | 0.37432    | 0.37432    |   0.0 |  0.27
Other   |            | 0.05587    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5695.00 ave        5695 max        5695 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:      222854.0 ave      222854 max      222854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222854
Ave neighs/atom = 55.713500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.434139538834, Press = -0.112162767815064
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -13157.475   -13157.475   -13298.106   -13298.106    272.06119    272.06119    67254.511    67254.511    12.712013    12.712013 
   88000   -13154.027   -13154.027   -13295.678   -13295.678    274.03282    274.03282    67254.589    67254.589    212.91772    212.91772 
Loop time of 122.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.703 ns/day, 34.157 hours/ns, 8.132 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    | 122.54     | 122.54     | 122.54     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052914   | 0.052914   | 0.052914   |   0.0 |  0.04
Output  | 0.00018811 | 0.00018811 | 0.00018811 |   0.0 |  0.00
Modify  | 0.32785    | 0.32785    | 0.32785    |   0.0 |  0.27
Other   |            | 0.04787    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5731.00 ave        5731 max        5731 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:      223102.0 ave      223102 max      223102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223102
Ave neighs/atom = 55.775500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.436006455366, Press = -0.201260775052088
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -13154.027   -13154.027   -13295.678   -13295.678    274.03282    274.03282    67254.589    67254.589    212.91772    212.91772 
   89000   -13154.244   -13154.244   -13294.961   -13294.961    272.22817    272.22817    67254.861    67254.861    208.10798    208.10798 
Loop time of 136.01 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.635 ns/day, 37.781 hours/ns, 7.352 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    | 135.53     | 135.53     | 135.53     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059691   | 0.059691   | 0.059691   |   0.0 |  0.04
Output  | 0.00012329 | 0.00012329 | 0.00012329 |   0.0 |  0.00
Modify  | 0.36626    | 0.36626    | 0.36626    |   0.0 |  0.27
Other   |            | 0.0541     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5721.00 ave        5721 max        5721 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:      222952.0 ave      222952 max      222952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222952
Ave neighs/atom = 55.738000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.432932023709, Press = -0.378384120150628
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -13154.244   -13154.244   -13294.961   -13294.961    272.22817    272.22817    67254.861    67254.861    208.10798    208.10798 
   90000   -13155.723   -13155.723   -13296.803   -13296.803    272.92952    272.92952    67295.814    67295.814   -337.57749   -337.57749 
Loop time of 132.786 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.651 ns/day, 36.885 hours/ns, 7.531 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    | 132.32     | 132.32     | 132.32     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057477   | 0.057477   | 0.057477   |   0.0 |  0.04
Output  | 0.00064651 | 0.00064651 | 0.00064651 |   0.0 |  0.00
Modify  | 0.3541     | 0.3541     | 0.3541     |   0.0 |  0.27
Other   |            | 0.05267    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5723.00 ave        5723 max        5723 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:      223228.0 ave      223228 max      223228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223228
Ave neighs/atom = 55.807000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.436121087678, Press = -0.65500573622991
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -13155.723   -13155.723   -13296.803   -13296.803    272.92952    272.92952    67295.814    67295.814   -337.57749   -337.57749 
   91000   -13151.001   -13151.001    -13295.64    -13295.64    279.81395    279.81395    67379.801    67379.801   -1057.4353   -1057.4353 
Loop time of 119.297 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.724 ns/day, 33.138 hours/ns, 8.382 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    | 118.88     | 118.88     | 118.88     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050996   | 0.050996   | 0.050996   |   0.0 |  0.04
Output  | 0.00010148 | 0.00010148 | 0.00010148 |   0.0 |  0.00
Modify  | 0.31534    | 0.31534    | 0.31534    |   0.0 |  0.26
Other   |            | 0.04594    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5664.00 ave        5664 max        5664 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:      222654.0 ave      222654 max      222654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222654
Ave neighs/atom = 55.663500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.446573930197, Press = -0.493565753415561
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -13151.001   -13151.001    -13295.64    -13295.64    279.81395    279.81395    67379.801    67379.801   -1057.4353   -1057.4353 
   92000   -13156.808   -13156.808   -13295.434   -13295.434    268.18132    268.18132    67339.717    67339.717   -807.03335   -807.03335 
Loop time of 142.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.608 ns/day, 39.490 hours/ns, 7.034 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    | 141.66     | 141.66     | 141.66     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062176   | 0.062176   | 0.062176   |   0.0 |  0.04
Output  | 9.9276e-05 | 9.9276e-05 | 9.9276e-05 |   0.0 |  0.00
Modify  | 0.38077    | 0.38077    | 0.38077    |   0.0 |  0.27
Other   |            | 0.05593    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5722.00 ave        5722 max        5722 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:      222706.0 ave      222706 max      222706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222706
Ave neighs/atom = 55.676500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.448783677665, Press = -0.212098175984301
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -13156.808   -13156.808   -13295.434   -13295.434    268.18132    268.18132    67339.717    67339.717   -807.03335   -807.03335 
   93000   -13150.463   -13150.463   -13295.171   -13295.171    279.94621    279.94621    67334.235    67334.235   -579.72114   -579.72114 
Loop time of 159.626 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.541 ns/day, 44.341 hours/ns, 6.265 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    | 159.07     | 159.07     | 159.07     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069122   | 0.069122   | 0.069122   |   0.0 |  0.04
Output  | 0.00036566 | 0.00036566 | 0.00036566 |   0.0 |  0.00
Modify  | 0.42369    | 0.42369    | 0.42369    |   0.0 |  0.27
Other   |            | 0.06267    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5728.00 ave        5728 max        5728 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:      222920.0 ave      222920 max      222920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222920
Ave neighs/atom = 55.730000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.461708455207, Press = -0.0535809897418463
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -13150.463   -13150.463   -13295.171   -13295.171    279.94621    279.94621    67334.235    67334.235   -579.72114   -579.72114 
   94000   -13155.426   -13155.426   -13297.927   -13297.927    275.67625    275.67625    67265.115    67265.115   -19.071254   -19.071254 
Loop time of 186.415 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.782 hours/ns, 5.364 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    | 185.77     | 185.77     | 185.77     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079671   | 0.079671   | 0.079671   |   0.0 |  0.04
Output  | 0.00030202 | 0.00030202 | 0.00030202 |   0.0 |  0.00
Modify  | 0.49315    | 0.49315    | 0.49315    |   0.0 |  0.26
Other   |            | 0.07219    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5721.00 ave        5721 max        5721 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:      222834.0 ave      222834 max      222834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222834
Ave neighs/atom = 55.708500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.45910129509, Press = -0.111156964367714
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -13155.426   -13155.426   -13297.927   -13297.927    275.67625    275.67625    67265.115    67265.115   -19.071254   -19.071254 
   95000    -13156.12    -13156.12   -13296.963   -13296.963    272.47111    272.47111    67236.664    67236.664    269.11141    269.11141 
Loop time of 195.112 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.198 hours/ns, 5.125 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    | 194.44     | 194.44     | 194.44     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083097   | 0.083097   | 0.083097   |   0.0 |  0.04
Output  | 0.00021739 | 0.00021739 | 0.00021739 |   0.0 |  0.00
Modify  | 0.51458    | 0.51458    | 0.51458    |   0.0 |  0.26
Other   |            | 0.07357    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5705.00 ave        5705 max        5705 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:      222886.0 ave      222886 max      222886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222886
Ave neighs/atom = 55.721500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.466395275519, Press = -0.228383133812421
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000    -13156.12    -13156.12   -13296.963   -13296.963    272.47111    272.47111    67236.664    67236.664    269.11141    269.11141 
   96000   -13153.209   -13153.209   -13293.509   -13293.509    271.41927    271.41927    67256.329    67256.329    242.15584    242.15584 
Loop time of 225.382 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.606 hours/ns, 4.437 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    | 224.63     | 224.63     | 224.63     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093401   | 0.093401   | 0.093401   |   0.0 |  0.04
Output  | 0.00018382 | 0.00018382 | 0.00018382 |   0.0 |  0.00
Modify  | 0.58253    | 0.58253    | 0.58253    |   0.0 |  0.26
Other   |            | 0.07929    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5710.00 ave        5710 max        5710 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:      222920.0 ave      222920 max      222920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222920
Ave neighs/atom = 55.730000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.458848692808, Press = -0.347864214199321
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -13153.209   -13153.209   -13293.509   -13293.509    271.41927    271.41927    67256.329    67256.329    242.15584    242.15584 
   97000    -13157.01    -13157.01    -13298.88    -13298.88    274.45699    274.45699    67263.581    67263.581   -93.003207   -93.003207 
Loop time of 204.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.915 hours/ns, 4.881 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    | 204.2      | 204.2      | 204.2      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086468   | 0.086468   | 0.086468   |   0.0 |  0.04
Output  | 0.00019507 | 0.00019507 | 0.00019507 |   0.0 |  0.00
Modify  | 0.53751    | 0.53751    | 0.53751    |   0.0 |  0.26
Other   |            | 0.07581    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5705.00 ave        5705 max        5705 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:      223350.0 ave      223350 max      223350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223350
Ave neighs/atom = 55.837500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.456810223138, Press = -0.596249322813089
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000    -13157.01    -13157.01    -13298.88    -13298.88    274.45699    274.45699    67263.581    67263.581   -93.003207   -93.003207 
   98000   -13149.983   -13149.983   -13293.361   -13293.361    277.37559    277.37559     67383.41     67383.41   -989.93875   -989.93875 
Loop time of 155.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.554 ns/day, 43.287 hours/ns, 6.417 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    | 155.29     | 155.29     | 155.29     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066767   | 0.066767   | 0.066767   |   0.0 |  0.04
Output  | 0.00010556 | 0.00010556 | 0.00010556 |   0.0 |  0.00
Modify  | 0.41137    | 0.41137    | 0.41137    |   0.0 |  0.26
Other   |            | 0.0597     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5711.00 ave        5711 max        5711 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:      222768.0 ave      222768 max      222768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222768
Ave neighs/atom = 55.692000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.470783770869, Press = -0.514836044979798
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -13149.983   -13149.983   -13293.361   -13293.361    277.37559    277.37559     67383.41     67383.41   -989.93875   -989.93875 
   99000   -13154.579   -13154.579   -13294.888   -13294.888    271.43827    271.43827    67335.663    67335.663   -654.49049   -654.49049 
Loop time of 141.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.611 ns/day, 39.266 hours/ns, 7.074 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    | 140.87     | 140.87     | 140.87     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060274   | 0.060274   | 0.060274   |   0.0 |  0.04
Output  | 0.00019589 | 0.00019589 | 0.00019589 |   0.0 |  0.00
Modify  | 0.3718     | 0.3718     | 0.3718     |   0.0 |  0.26
Other   |            | 0.05556    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5715.00 ave        5715 max        5715 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:      222996.0 ave      222996 max      222996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222996
Ave neighs/atom = 55.749000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.47227322168, Press = -0.227836919990927
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -13154.579   -13154.579   -13294.888   -13294.888    271.43827    271.43827    67335.663    67335.663   -654.49049   -654.49049 
  100000   -13150.654   -13150.654   -13294.131   -13294.131    277.56694    277.56694    67311.559    67311.559    -284.0041    -284.0041 
Loop time of 118.978 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.726 ns/day, 33.049 hours/ns, 8.405 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    | 118.57     | 118.57     | 118.57     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049914   | 0.049914   | 0.049914   |   0.0 |  0.04
Output  | 0.00010288 | 0.00010288 | 0.00010288 |   0.0 |  0.00
Modify  | 0.31245    | 0.31245    | 0.31245    |   0.0 |  0.26
Other   |            | 0.04523    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5720.00 ave        5720 max        5720 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:      222790.0 ave      222790 max      222790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222790
Ave neighs/atom = 55.697500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.489818118411, Press = -0.0937551674458437
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -13150.654   -13150.654   -13294.131   -13294.131    277.56694    277.56694    67311.559    67311.559    -284.0041    -284.0041 
  101000   -13152.835   -13152.835   -13293.411   -13293.411    271.95308    271.95308     67287.59     67287.59   -68.076435   -68.076435 
Loop time of 123.156 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.702 ns/day, 34.210 hours/ns, 8.120 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    | 122.73     | 122.73     | 122.73     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051613   | 0.051613   | 0.051613   |   0.0 |  0.04
Output  | 0.0001031  | 0.0001031  | 0.0001031  |   0.0 |  0.00
Modify  | 0.32402    | 0.32402    | 0.32402    |   0.0 |  0.26
Other   |            | 0.04702    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5694.00 ave        5694 max        5694 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:      222780.0 ave      222780 max      222780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222780
Ave neighs/atom = 55.695000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.487173758205, Press = -0.0382606876415204
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -13152.835   -13152.835   -13293.411   -13293.411    271.95308    271.95308     67287.59     67287.59   -68.076435   -68.076435 
  102000   -13156.963   -13156.963   -13297.331   -13297.331    271.55102    271.55102    67219.272    67219.272    386.97413    386.97413 
Loop time of 115.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.745 ns/day, 32.217 hours/ns, 8.622 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    | 115.58     | 115.58     | 115.58     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048504   | 0.048504   | 0.048504   |   0.0 |  0.04
Output  | 0.00010557 | 0.00010557 | 0.00010557 |   0.0 |  0.00
Modify  | 0.30414    | 0.30414    | 0.30414    |   0.0 |  0.26
Other   |            | 0.04457    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5698.00 ave        5698 max        5698 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:      223234.0 ave      223234 max      223234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223234
Ave neighs/atom = 55.808500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.492299309081, Press = -0.106446224218581
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -13156.963   -13156.963   -13297.331   -13297.331    271.55102    271.55102    67219.272    67219.272    386.97413    386.97413 
  103000   -13153.021   -13153.021   -13296.281   -13296.281    277.14698    277.14698    67179.159    67179.159    1003.5096    1003.5096 
Loop time of 143.976 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.600 ns/day, 39.993 hours/ns, 6.946 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    | 143.47     | 143.47     | 143.47     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062118   | 0.062118   | 0.062118   |   0.0 |  0.04
Output  | 9.9566e-05 | 9.9566e-05 | 9.9566e-05 |   0.0 |  0.00
Modify  | 0.38162    | 0.38162    | 0.38162    |   0.0 |  0.27
Other   |            | 0.05709    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5699.00 ave        5699 max        5699 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:      223194.0 ave      223194 max      223194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223194
Ave neighs/atom = 55.798500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.47647236852, Press = -0.330269133562135
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -13153.021   -13153.021   -13296.281   -13296.281    277.14698    277.14698    67179.159    67179.159    1003.5096    1003.5096 
  104000   -13154.903   -13154.903   -13296.661   -13296.661    274.24082    274.24082    67212.882    67212.882    645.55388    645.55388 
Loop time of 146.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.590 ns/day, 40.676 hours/ns, 6.829 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    | 145.92     | 145.92     | 145.92     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0639     | 0.0639     | 0.0639     |   0.0 |  0.04
Output  | 0.00011196 | 0.00011196 | 0.00011196 |   0.0 |  0.00
Modify  | 0.38824    | 0.38824    | 0.38824    |   0.0 |  0.27
Other   |            | 0.05937    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5747.00 ave        5747 max        5747 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:      223360.0 ave      223360 max      223360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223360
Ave neighs/atom = 55.840000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.465324666384, Press = -0.595853386402113
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -13154.903   -13154.903   -13296.661   -13296.661    274.24082    274.24082    67212.882    67212.882    645.55388    645.55388 
  105000    -13149.54    -13149.54   -13294.007   -13294.007    279.48112    279.48112    67315.645    67315.645   -231.97309   -231.97309 
Loop time of 136.656 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.632 ns/day, 37.960 hours/ns, 7.318 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    | 136.17     | 136.17     | 136.17     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059558   | 0.059558   | 0.059558   |   0.0 |  0.04
Output  | 0.00010284 | 0.00010284 | 0.00010284 |   0.0 |  0.00
Modify  | 0.36781    | 0.36781    | 0.36781    |   0.0 |  0.27
Other   |            | 0.05754    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5725.00 ave        5725 max        5725 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:      223240.0 ave      223240 max      223240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223240
Ave neighs/atom = 55.810000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.464106294022, Press = -0.448262009084071
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000    -13149.54    -13149.54   -13294.007   -13294.007    279.48112    279.48112    67315.645    67315.645   -231.97309   -231.97309 
  106000   -13154.324   -13154.324   -13295.849   -13295.849     273.7896     273.7896    67313.018    67313.018   -424.78453   -424.78453 
Loop time of 124.284 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.695 ns/day, 34.523 hours/ns, 8.046 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.86     | 123.86     | 123.86     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052542   | 0.052542   | 0.052542   |   0.0 |  0.04
Output  | 0.00010542 | 0.00010542 | 0.00010542 |   0.0 |  0.00
Modify  | 0.32716    | 0.32716    | 0.32716    |   0.0 |  0.26
Other   |            | 0.04783    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5707.00 ave        5707 max        5707 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:      222936.0 ave      222936 max      222936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222936
Ave neighs/atom = 55.734000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.471351427262, Press = -0.303860872958426
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000   -13154.324   -13154.324   -13295.849   -13295.849     273.7896     273.7896    67313.018    67313.018   -424.78453   -424.78453 
  107000   -13154.681   -13154.681   -13294.237   -13294.237    269.98004    269.98004     67339.31     67339.31   -637.01455   -637.01455 
Loop time of 118.823 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.727 ns/day, 33.006 hours/ns, 8.416 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    | 118.42     | 118.42     | 118.42     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050269   | 0.050269   | 0.050269   |   0.0 |  0.04
Output  | 0.00010688 | 0.00010688 | 0.00010688 |   0.0 |  0.00
Modify  | 0.31154    | 0.31154    | 0.31154    |   0.0 |  0.26
Other   |            | 0.04533    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5730.00 ave        5730 max        5730 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:      222668.0 ave      222668 max      222668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222668
Ave neighs/atom = 55.667000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.467474395338, Press = -0.182450728068596
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -13154.681   -13154.681   -13294.237   -13294.237    269.98004    269.98004     67339.31     67339.31   -637.01455   -637.01455 
  108000   -13156.464   -13156.464   -13297.813   -13297.813    273.44925    273.44925    67316.656    67316.656    -584.9952    -584.9952 
Loop time of 119.649 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.722 ns/day, 33.236 hours/ns, 8.358 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    | 119.24     | 119.24     | 119.24     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050527   | 0.050527   | 0.050527   |   0.0 |  0.04
Output  | 0.00010345 | 0.00010345 | 0.00010345 |   0.0 |  0.00
Modify  | 0.31598    | 0.31598    | 0.31598    |   0.0 |  0.26
Other   |            | 0.04627    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5690.00 ave        5690 max        5690 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:      222872.0 ave      222872 max      222872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222872
Ave neighs/atom = 55.718000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.447433901309, Press = 0.0164467047863499
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -13156.464   -13156.464   -13297.813   -13297.813    273.44925    273.44925    67316.656    67316.656    -584.9952    -584.9952 
  109000   -13151.544   -13151.544   -13294.779   -13294.779    277.09707    277.09707    67305.677    67305.677   -315.41879   -315.41879 
Loop time of 117.03 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.738 ns/day, 32.508 hours/ns, 8.545 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    | 116.63     | 116.63     | 116.63     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049932   | 0.049932   | 0.049932   |   0.0 |  0.04
Output  | 0.0001066  | 0.0001066  | 0.0001066  |   0.0 |  0.00
Modify  | 0.30776    | 0.30776    | 0.30776    |   0.0 |  0.26
Other   |            | 0.04546    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5738.00 ave        5738 max        5738 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:      222700.0 ave      222700 max      222700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222700
Ave neighs/atom = 55.675000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.441786442577, Press = 0.131217429302949
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -13151.544   -13151.544   -13294.779   -13294.779    277.09707    277.09707    67305.677    67305.677   -315.41879   -315.41879 
  110000   -13150.388   -13150.388   -13294.027   -13294.027    277.87899    277.87899    67250.907    67250.907    355.92718    355.92718 
Loop time of 123.598 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.699 ns/day, 34.333 hours/ns, 8.091 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    | 123.17     | 123.17     | 123.17     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052629   | 0.052629   | 0.052629   |   0.0 |  0.04
Output  | 0.00011078 | 0.00011078 | 0.00011078 |   0.0 |  0.00
Modify  | 0.32556    | 0.32556    | 0.32556    |   0.0 |  0.26
Other   |            | 0.0475     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5705.00 ave        5705 max        5705 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:      223156.0 ave      223156 max      223156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223156
Ave neighs/atom = 55.789000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.443292042072, Press = 0.122292496165333
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -13150.388   -13150.388   -13294.027   -13294.027    277.87899    277.87899    67250.907    67250.907    355.92718    355.92718 
  111000   -13155.759   -13155.759   -13297.885   -13297.885    274.95226    274.95226    67186.196    67186.196     797.7994     797.7994 
Loop time of 118.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.727 ns/day, 33.008 hours/ns, 8.415 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.42     | 118.42     | 118.42     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051213   | 0.051213   | 0.051213   |   0.0 |  0.04
Output  | 0.0001069  | 0.0001069  | 0.0001069  |   0.0 |  0.00
Modify  | 0.31427    | 0.31427    | 0.31427    |   0.0 |  0.26
Other   |            | 0.04676    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5740.00 ave        5740 max        5740 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:      223262.0 ave      223262 max      223262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223262
Ave neighs/atom = 55.815500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.461742003767, Press = -0.0882034782179259
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -13155.759   -13155.759   -13297.885   -13297.885    274.95226    274.95226    67186.196    67186.196     797.7994     797.7994 
  112000   -13155.267   -13155.267   -13293.309   -13293.309    267.05142    267.05142     67192.86     67192.86    937.77456    937.77456 
Loop time of 126.808 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.681 ns/day, 35.224 hours/ns, 7.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    | 126.37     | 126.37     | 126.37     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053617   | 0.053617   | 0.053617   |   0.0 |  0.04
Output  | 0.00010692 | 0.00010692 | 0.00010692 |   0.0 |  0.00
Modify  | 0.33509    | 0.33509    | 0.33509    |   0.0 |  0.26
Other   |            | 0.04889    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5717.00 ave        5717 max        5717 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:      223190.0 ave      223190 max      223190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223190
Ave neighs/atom = 55.797500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.459664444678, Press = -0.290806033074609
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -13155.267   -13155.267   -13293.309   -13293.309    267.05142    267.05142     67192.86     67192.86    937.77456    937.77456 
  113000   -13155.495   -13155.495   -13295.727   -13295.727    271.28907    271.28907    67244.261    67244.261    300.35858    300.35858 
Loop time of 124.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.697 ns/day, 34.451 hours/ns, 8.063 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    | 123.59     | 123.59     | 123.59     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052938   | 0.052938   | 0.052938   |   0.0 |  0.04
Output  | 0.00010245 | 0.00010245 | 0.00010245 |   0.0 |  0.00
Modify  | 0.32831    | 0.32831    | 0.32831    |   0.0 |  0.26
Other   |            | 0.04837    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5743.00 ave        5743 max        5743 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:      223760.0 ave      223760 max      223760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223760
Ave neighs/atom = 55.940000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454845442944, Press = -0.397719422343092
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -13155.495   -13155.495   -13295.727   -13295.727    271.28907    271.28907    67244.261    67244.261    300.35858    300.35858 
  114000   -13154.592   -13154.592   -13294.856   -13294.856    271.35197    271.35197    67289.255    67289.255   -146.54436   -146.54436 
Loop time of 119.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.725 ns/day, 33.102 hours/ns, 8.392 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    | 118.76     | 118.76     | 118.76     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050511   | 0.050511   | 0.050511   |   0.0 |  0.04
Output  | 0.00010458 | 0.00010458 | 0.00010458 |   0.0 |  0.00
Modify  | 0.31399    | 0.31399    | 0.31399    |   0.0 |  0.26
Other   |            | 0.04587    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5698.00 ave        5698 max        5698 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:      223212.0 ave      223212 max      223212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223212
Ave neighs/atom = 55.803000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.443846685147, Press = -0.39953487252801
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000   -13154.592   -13154.592   -13294.856   -13294.856    271.35197    271.35197    67289.255    67289.255   -146.54436   -146.54436 
  115000   -13155.042   -13155.042   -13295.321   -13295.321    271.37827    271.37827     67315.27     67315.27   -419.44927   -419.44927 
Loop time of 125.355 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.821 hours/ns, 7.977 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    | 124.92     | 124.92     | 124.92     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052693   | 0.052693   | 0.052693   |   0.0 |  0.04
Output  | 0.00024416 | 0.00024416 | 0.00024416 |   0.0 |  0.00
Modify  | 0.32982    | 0.32982    | 0.32982    |   0.0 |  0.26
Other   |            | 0.04807    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      223138.0 ave      223138 max      223138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223138
Ave neighs/atom = 55.784500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.442493260749, Press = -0.265022301293641
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -13155.042   -13155.042   -13295.321   -13295.321    271.37827    271.37827     67315.27     67315.27   -419.44927   -419.44927 
  116000   -13150.176   -13150.176   -13292.506   -13292.506    275.34803    275.34803    67320.336    67320.336   -302.58166   -302.58166 
Loop time of 119.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.721 ns/day, 33.285 hours/ns, 8.346 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    | 119.41     | 119.41     | 119.41     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05084    | 0.05084    | 0.05084    |   0.0 |  0.04
Output  | 0.00010452 | 0.00010452 | 0.00010452 |   0.0 |  0.00
Modify  | 0.31636    | 0.31636    | 0.31636    |   0.0 |  0.26
Other   |            | 0.04692    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5699.00 ave        5699 max        5699 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:      222742.0 ave      222742 max      222742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222742
Ave neighs/atom = 55.685500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.442389305562, Press = -0.163287247562017
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -13150.176   -13150.176   -13292.506   -13292.506    275.34803    275.34803    67320.336    67320.336   -302.58166   -302.58166 
  117000   -13154.666   -13154.666   -13295.165   -13295.165    271.80643    271.80643    67291.364    67291.364   -167.78053   -167.78053 
Loop time of 119.263 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.724 ns/day, 33.129 hours/ns, 8.385 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    | 118.85     | 118.85     | 118.85     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050274   | 0.050274   | 0.050274   |   0.0 |  0.04
Output  | 0.00010615 | 0.00010615 | 0.00010615 |   0.0 |  0.00
Modify  | 0.31449    | 0.31449    | 0.31449    |   0.0 |  0.26
Other   |            | 0.04594    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5711.00 ave        5711 max        5711 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:      223062.0 ave      223062 max      223062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223062
Ave neighs/atom = 55.765500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.444876860243, Press = -0.206262016932005
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -13154.666   -13154.666   -13295.165   -13295.165    271.80643    271.80643    67291.364    67291.364   -167.78053   -167.78053 
  118000   -13152.495   -13152.495    -13295.58    -13295.58    276.80781    276.80781    67305.354    67305.354   -272.23747   -272.23747 
Loop time of 127.219 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.679 ns/day, 35.339 hours/ns, 7.860 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    | 126.78     | 126.78     | 126.78     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054731   | 0.054731   | 0.054731   |   0.0 |  0.04
Output  | 0.00010617 | 0.00010617 | 0.00010617 |   0.0 |  0.00
Modify  | 0.33771    | 0.33771    | 0.33771    |   0.0 |  0.27
Other   |            | 0.04989    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5711.00 ave        5711 max        5711 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:      223086.0 ave      223086 max      223086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223086
Ave neighs/atom = 55.771500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.460786591528, Press = -0.242744869855056
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -13152.495   -13152.495    -13295.58    -13295.58    276.80781    276.80781    67305.354    67305.354   -272.23747   -272.23747 
  119000   -13155.283   -13155.283   -13298.388   -13298.388    276.84687    276.84687    67359.343    67359.343   -986.33166   -986.33166 
Loop time of 121.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.713 ns/day, 33.650 hours/ns, 8.255 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    | 120.72     | 120.72     | 120.72     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051038   | 0.051038   | 0.051038   |   0.0 |  0.04
Output  | 0.00010424 | 0.00010424 | 0.00010424 |   0.0 |  0.00
Modify  | 0.31951    | 0.31951    | 0.31951    |   0.0 |  0.26
Other   |            | 0.04643    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5675.00 ave        5675 max        5675 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:      223098.0 ave      223098 max      223098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223098
Ave neighs/atom = 55.774500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.460842311243, Press = -0.240861048936821
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000   -13155.283   -13155.283   -13298.388   -13298.388    276.84687    276.84687    67359.343    67359.343   -986.33166   -986.33166 
  120000   -13150.416   -13150.416   -13292.231   -13292.231     274.3506     274.3506    67397.534    67397.534    -1082.459    -1082.459 
Loop time of 117.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.735 ns/day, 32.661 hours/ns, 8.505 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    | 117.18     | 117.18     | 117.18     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049483   | 0.049483   | 0.049483   |   0.0 |  0.04
Output  | 0.00010616 | 0.00010616 | 0.00010616 |   0.0 |  0.00
Modify  | 0.30918    | 0.30918    | 0.30918    |   0.0 |  0.26
Other   |            | 0.04514    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5660.00 ave        5660 max        5660 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:      222524.0 ave      222524 max      222524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222524
Ave neighs/atom = 55.631000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.474513909768, Press = -0.0986193283198207
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -13150.416   -13150.416   -13292.231   -13292.231     274.3506     274.3506    67397.534    67397.534    -1082.459    -1082.459 
  121000   -13157.458   -13157.458   -13297.664   -13297.664    271.23798    271.23798    67313.368    67313.368   -503.47389   -503.47389 
Loop time of 118.343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.730 ns/day, 32.873 hours/ns, 8.450 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    | 117.94     | 117.94     | 117.94     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050076   | 0.050076   | 0.050076   |   0.0 |  0.04
Output  | 0.00010528 | 0.00010528 | 0.00010528 |   0.0 |  0.00
Modify  | 0.31081    | 0.31081    | 0.31081    |   0.0 |  0.26
Other   |            | 0.04529    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5687.00 ave        5687 max        5687 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:      222876.0 ave      222876 max      222876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222876
Ave neighs/atom = 55.719000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.474224855838, Press = 0.134661678736269
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000   -13157.458   -13157.458   -13297.664   -13297.664    271.23798    271.23798    67313.368    67313.368   -503.47389   -503.47389 
  122000    -13154.31    -13154.31   -13293.713   -13293.713    269.68497    269.68497    67260.516    67260.516     212.3301     212.3301 
Loop time of 115.29 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.749 ns/day, 32.025 hours/ns, 8.674 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    | 114.89     | 114.89     | 114.89     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048256   | 0.048256   | 0.048256   |   0.0 |  0.04
Output  | 0.00010606 | 0.00010606 | 0.00010606 |   0.0 |  0.00
Modify  | 0.3033     | 0.3033     | 0.3033     |   0.0 |  0.26
Other   |            | 0.04422    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5689.00 ave        5689 max        5689 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:      222666.0 ave      222666 max      222666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222666
Ave neighs/atom = 55.666500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.478857436782, Press = -0.0013560211608742
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  122000    -13154.31    -13154.31   -13293.713   -13293.713    269.68497    269.68497    67260.516    67260.516     212.3301     212.3301 
  123000   -13152.782   -13152.782    -13295.73    -13295.73    276.54252    276.54252    67268.849    67268.849    52.121653    52.121653 
Loop time of 131.277 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.658 ns/day, 36.466 hours/ns, 7.618 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    | 130.82     | 130.82     | 130.82     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05694    | 0.05694    | 0.05694    |   0.0 |  0.04
Output  | 0.00037365 | 0.00037365 | 0.00037365 |   0.0 |  0.00
Modify  | 0.34945    | 0.34945    | 0.34945    |   0.0 |  0.27
Other   |            | 0.05183    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5713.00 ave        5713 max        5713 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:      223118.0 ave      223118 max      223118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223118
Ave neighs/atom = 55.779500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.481027653521, Press = -0.0554456410661146
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  123000   -13152.782   -13152.782    -13295.73    -13295.73    276.54252    276.54252    67268.849    67268.849    52.121653    52.121653 
  124000   -13154.211   -13154.211   -13297.197   -13297.197    276.61544    276.61544    67262.561    67262.561    24.211669    24.211669 
Loop time of 132.703 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.651 ns/day, 36.862 hours/ns, 7.536 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.25     | 132.25     | 132.25     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055919   | 0.055919   | 0.055919   |   0.0 |  0.04
Output  | 0.00010509 | 0.00010509 | 0.00010509 |   0.0 |  0.00
Modify  | 0.34966    | 0.34966    | 0.34966    |   0.0 |  0.26
Other   |            | 0.0505     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5710.00 ave        5710 max        5710 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:      222932.0 ave      222932 max      222932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222932
Ave neighs/atom = 55.733000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.491961774392, Press = -0.152439699068424
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  124000   -13154.211   -13154.211   -13297.197   -13297.197    276.61544    276.61544    67262.561    67262.561    24.211669    24.211669 
  125000   -13155.587   -13155.587   -13295.064   -13295.064     269.8287     269.8287     67245.86     67245.86    244.46855    244.46855 
Loop time of 123.282 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.701 ns/day, 34.245 hours/ns, 8.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    | 122.85     | 122.85     | 122.85     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052798   | 0.052798   | 0.052798   |   0.0 |  0.04
Output  | 0.00010646 | 0.00010646 | 0.00010646 |   0.0 |  0.00
Modify  | 0.32669    | 0.32669    | 0.32669    |   0.0 |  0.26
Other   |            | 0.04844    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5731.00 ave        5731 max        5731 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:      223060.0 ave      223060 max      223060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223060
Ave neighs/atom = 55.765000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.497102577523, Press = -0.157350196399266
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  125000   -13155.587   -13155.587   -13295.064   -13295.064     269.8287     269.8287     67245.86     67245.86    244.46855    244.46855 
  126000   -13157.873   -13157.873   -13298.015   -13298.015    271.11423    271.11423    67216.504    67216.504     502.6453     502.6453 
Loop time of 114.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.672 hours/ns, 8.771 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    | 113.63     | 113.63     | 113.63     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047773   | 0.047773   | 0.047773   |   0.0 |  0.04
Output  | 0.00010505 | 0.00010505 | 0.00010505 |   0.0 |  0.00
Modify  | 0.29829    | 0.29829    | 0.29829    |   0.0 |  0.26
Other   |            | 0.04304    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5731.00 ave        5731 max        5731 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:      223216.0 ave      223216 max      223216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223216
Ave neighs/atom = 55.804000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.501332805463, Press = -0.290032561812462
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  126000   -13157.873   -13157.873   -13298.015   -13298.015    271.11423    271.11423    67216.504    67216.504     502.6453     502.6453 
  127000   -13154.246   -13154.246   -13293.399   -13293.399    269.20013    269.20013    67282.961    67282.961     22.77464     22.77464 
Loop time of 120.217 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.719 ns/day, 33.394 hours/ns, 8.318 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    | 119.8      | 119.8      | 119.8      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050863   | 0.050863   | 0.050863   |   0.0 |  0.04
Output  | 0.00011947 | 0.00011947 | 0.00011947 |   0.0 |  0.00
Modify  | 0.31611    | 0.31611    | 0.31611    |   0.0 |  0.26
Other   |            | 0.04634    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      222996.0 ave      222996 max      222996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222996
Ave neighs/atom = 55.749000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.486090070935, Press = -0.42599893059261
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  127000   -13154.246   -13154.246   -13293.399   -13293.399    269.20013    269.20013    67282.961    67282.961     22.77464     22.77464 
  128000   -13157.654   -13157.654   -13294.121   -13294.121    264.00357    264.00357     67332.19     67332.19   -693.14722   -693.14722 
Loop time of 151.113 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.572 ns/day, 41.976 hours/ns, 6.618 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    | 150.58     | 150.58     | 150.58     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065533   | 0.065533   | 0.065533   |   0.0 |  0.04
Output  | 0.00018431 | 0.00018431 | 0.00018431 |   0.0 |  0.00
Modify  | 0.40357    | 0.40357    | 0.40357    |   0.0 |  0.27
Other   |            | 0.06143    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      223070.0 ave      223070 max      223070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223070
Ave neighs/atom = 55.767500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.479955740593, Press = -0.432825417623926
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  128000   -13157.654   -13157.654   -13294.121   -13294.121    264.00357    264.00357     67332.19     67332.19   -693.14722   -693.14722 
  129000   -13155.869   -13155.869   -13296.973   -13296.973    272.97544    272.97544    67361.631    67361.631   -975.81003   -975.81003 
Loop time of 152.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.567 ns/day, 42.350 hours/ns, 6.559 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    | 151.92     | 151.92     | 151.92     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065457   | 0.065457   | 0.065457   |   0.0 |  0.04
Output  | 0.00010276 | 0.00010276 | 0.00010276 |   0.0 |  0.00
Modify  | 0.40926    | 0.40926    | 0.40926    |   0.0 |  0.27
Other   |            | 0.06344    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5690.00 ave        5690 max        5690 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:      223134.0 ave      223134 max      223134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223134
Ave neighs/atom = 55.783500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.459632144557, Press = -0.238335652325374
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  129000   -13155.869   -13155.869   -13296.973   -13296.973    272.97544    272.97544    67361.631    67361.631   -975.81003   -975.81003 
  130000   -13154.405   -13154.405   -13296.605   -13296.605    275.09574    275.09574    67322.331    67322.331   -590.22485   -590.22485 
Loop time of 142.046 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.608 ns/day, 39.457 hours/ns, 7.040 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    | 141.54     | 141.54     | 141.54     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061162   | 0.061162   | 0.061162   |   0.0 |  0.04
Output  | 9.6539e-05 | 9.6539e-05 | 9.6539e-05 |   0.0 |  0.00
Modify  | 0.38189    | 0.38189    | 0.38189    |   0.0 |  0.27
Other   |            | 0.05902    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5700.00 ave        5700 max        5700 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:      222548.0 ave      222548 max      222548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222548
Ave neighs/atom = 55.637000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.459655694731, Press = -0.130885126338059
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  130000   -13154.405   -13154.405   -13296.605   -13296.605    275.09574    275.09574    67322.331    67322.331   -590.22485   -590.22485 
  131000   -13149.329   -13149.329   -13293.456   -13293.456    278.82419    278.82419    67319.761    67319.761   -365.79065   -365.79065 
Loop time of 140.947 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.613 ns/day, 39.152 hours/ns, 7.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    | 140.46     | 140.46     | 140.46     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05979    | 0.05979    | 0.05979    |   0.0 |  0.04
Output  | 0.0002322  | 0.0002322  | 0.0002322  |   0.0 |  0.00
Modify  | 0.37297    | 0.37297    | 0.37297    |   0.0 |  0.26
Other   |            | 0.05405    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5684.00 ave        5684 max        5684 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:      222784.0 ave      222784 max      222784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222784
Ave neighs/atom = 55.696000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.465328167944, Press = -0.148752924011579
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  131000   -13149.329   -13149.329   -13293.456   -13293.456    278.82419    278.82419    67319.761    67319.761   -365.79065   -365.79065 
  132000   -13156.277   -13156.277   -13299.175   -13299.175    276.44712    276.44712    67292.279    67292.279   -380.31347   -380.31347 
Loop time of 119.902 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.721 ns/day, 33.306 hours/ns, 8.340 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    | 119.48     | 119.48     | 119.48     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050911   | 0.050911   | 0.050911   |   0.0 |  0.04
Output  | 0.00010035 | 0.00010035 | 0.00010035 |   0.0 |  0.00
Modify  | 0.31827    | 0.31827    | 0.31827    |   0.0 |  0.27
Other   |            | 0.04752    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5681.00 ave        5681 max        5681 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:      223226.0 ave      223226 max      223226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223226
Ave neighs/atom = 55.806500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.471499979638, Press = -0.0790059716277103
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  132000   -13156.277   -13156.277   -13299.175   -13299.175    276.44712    276.44712    67292.279    67292.279   -380.31347   -380.31347 
  133000   -13151.236   -13151.236   -13291.588   -13291.588     271.5204     271.5204    67263.444    67263.444    285.64117    285.64117 
Loop time of 118.383 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.730 ns/day, 32.884 hours/ns, 8.447 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    | 117.98     | 117.98     | 117.98     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049787   | 0.049787   | 0.049787   |   0.0 |  0.04
Output  | 0.00023674 | 0.00023674 | 0.00023674 |   0.0 |  0.00
Modify  | 0.31209    | 0.31209    | 0.31209    |   0.0 |  0.26
Other   |            | 0.04587    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5718.00 ave        5718 max        5718 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:      222902.0 ave      222902 max      222902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222902
Ave neighs/atom = 55.725500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.479270525729, Press = -0.00870699149504195
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  133000   -13151.236   -13151.236   -13291.588   -13291.588     271.5204     271.5204    67263.444    67263.444    285.64117    285.64117 
  134000   -13154.218   -13154.218   -13295.708   -13295.708    273.72088    273.72088    67219.064    67219.064    646.21932    646.21932 
Loop time of 118.937 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.726 ns/day, 33.038 hours/ns, 8.408 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    | 118.53     | 118.53     | 118.53     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049855   | 0.049855   | 0.049855   |   0.0 |  0.04
Output  | 0.00010085 | 0.00010085 | 0.00010085 |   0.0 |  0.00
Modify  | 0.31263    | 0.31263    | 0.31263    |   0.0 |  0.26
Other   |            | 0.04585    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5713.00 ave        5713 max        5713 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:      223410.0 ave      223410 max      223410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223410
Ave neighs/atom = 55.852500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.478451187457, Press = -0.0883925159433191
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  134000   -13154.218   -13154.218   -13295.708   -13295.708    273.72088    273.72088    67219.064    67219.064    646.21932    646.21932 
  135000   -13154.678   -13154.678   -13295.516   -13295.516    272.45941    272.45941    67156.973    67156.973    1262.0922    1262.0922 
Loop time of 126.79 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.681 ns/day, 35.219 hours/ns, 7.887 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    | 126.35     | 126.35     | 126.35     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05349    | 0.05349    | 0.05349    |   0.0 |  0.04
Output  | 9.7505e-05 | 9.7505e-05 | 9.7505e-05 |   0.0 |  0.00
Modify  | 0.33579    | 0.33579    | 0.33579    |   0.0 |  0.26
Other   |            | 0.05065    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5688.00 ave        5688 max        5688 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:      223126.0 ave      223126 max      223126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223126
Ave neighs/atom = 55.781500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.472652821046, Press = -0.255493769373249
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  135000   -13154.678   -13154.678   -13295.516   -13295.516    272.45941    272.45941    67156.973    67156.973    1262.0922    1262.0922 
  136000   -13154.777   -13154.777   -13295.737   -13295.737      272.696      272.696    67218.935    67218.935    540.01398    540.01398 
Loop time of 136.448 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.633 ns/day, 37.902 hours/ns, 7.329 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    | 135.97     | 135.97     | 135.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058587   | 0.058587   | 0.058587   |   0.0 |  0.04
Output  | 0.00025887 | 0.00025887 | 0.00025887 |   0.0 |  0.00
Modify  | 0.36166    | 0.36166    | 0.36166    |   0.0 |  0.27
Other   |            | 0.05408    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5715.00 ave        5715 max        5715 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:      223426.0 ave      223426 max      223426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223426
Ave neighs/atom = 55.856500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.480579770487, Press = -0.456180578289768
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  136000   -13154.777   -13154.777   -13295.737   -13295.737      272.696      272.696    67218.935    67218.935    540.01398    540.01398 
  137000   -13153.535   -13153.535    -13295.56    -13295.56    274.75737    274.75737    67293.125    67293.125   -121.35859   -121.35859 
Loop time of 116.853 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.739 ns/day, 32.459 hours/ns, 8.558 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    | 116.45     | 116.45     | 116.45     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049371   | 0.049371   | 0.049371   |   0.0 |  0.04
Output  | 9.7444e-05 | 9.7444e-05 | 9.7444e-05 |   0.0 |  0.00
Modify  | 0.30796    | 0.30796    | 0.30796    |   0.0 |  0.26
Other   |            | 0.04505    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5708.00 ave        5708 max        5708 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:      223194.0 ave      223194 max      223194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223194
Ave neighs/atom = 55.798500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.471129049585, Press = -0.318708329689932
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  137000   -13153.535   -13153.535    -13295.56    -13295.56    274.75737    274.75737    67293.125    67293.125   -121.35859   -121.35859 
  138000   -13157.746   -13157.746    -13297.81    -13297.81    270.96277    270.96277    67286.013    67286.013   -279.49259   -279.49259 
Loop time of 144.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.599 ns/day, 40.079 hours/ns, 6.931 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    | 143.79     | 143.79     | 143.79     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061319   | 0.061319   | 0.061319   |   0.0 |  0.04
Output  | 0.00010525 | 0.00010525 | 0.00010525 |   0.0 |  0.00
Modify  | 0.38163    | 0.38163    | 0.38163    |   0.0 |  0.26
Other   |            | 0.05654    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      223004.0 ave      223004 max      223004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223004
Ave neighs/atom = 55.751000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.459730961567, Press = -0.209184342368395
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  138000   -13157.746   -13157.746    -13297.81    -13297.81    270.96277    270.96277    67286.013    67286.013   -279.49259   -279.49259 
  139000   -13154.307   -13154.307   -13296.277   -13296.277     274.6515     274.6515    67312.153    67312.153   -412.28814   -412.28814 
Loop time of 129.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.667 ns/day, 35.974 hours/ns, 7.722 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    | 129.06     | 129.06     | 129.06     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054269   | 0.054269   | 0.054269   |   0.0 |  0.04
Output  | 9.8634e-05 | 9.8634e-05 | 9.8634e-05 |   0.0 |  0.00
Modify  | 0.34124    | 0.34124    | 0.34124    |   0.0 |  0.26
Other   |            | 0.04978    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5684.00 ave        5684 max        5684 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:      222686.0 ave      222686 max      222686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222686
Ave neighs/atom = 55.671500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.455996371972, Press = -0.14832319591737
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  139000   -13154.307   -13154.307   -13296.277   -13296.277     274.6515     274.6515    67312.153    67312.153   -412.28814   -412.28814 
  140000   -13155.688   -13155.688    -13294.24    -13294.24    268.03799    268.03799    67316.424    67316.424   -427.29992   -427.29992 
Loop time of 122.658 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.704 ns/day, 34.072 hours/ns, 8.153 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.24     | 122.24     | 122.24     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051543   | 0.051543   | 0.051543   |   0.0 |  0.04
Output  | 9.9956e-05 | 9.9956e-05 | 9.9956e-05 |   0.0 |  0.00
Modify  | 0.32306    | 0.32306    | 0.32306    |   0.0 |  0.26
Other   |            | 0.04686    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5725.00 ave        5725 max        5725 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:      222952.0 ave      222952 max      222952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222952
Ave neighs/atom = 55.738000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.455818982755, Press = -0.102922208811018
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  140000   -13155.688   -13155.688    -13294.24    -13294.24    268.03799    268.03799    67316.424    67316.424   -427.29992   -427.29992 
  141000   -13152.505   -13152.505   -13294.416   -13294.416    274.53713    274.53713    67331.157    67331.157   -557.72213   -557.72213 
Loop time of 122.306 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.706 ns/day, 33.974 hours/ns, 8.176 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    | 121.88     | 121.88     | 121.88     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051968   | 0.051968   | 0.051968   |   0.0 |  0.04
Output  | 9.9882e-05 | 9.9882e-05 | 9.9882e-05 |   0.0 |  0.00
Modify  | 0.32397    | 0.32397    | 0.32397    |   0.0 |  0.26
Other   |            | 0.04842    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5722.00 ave        5722 max        5722 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:      222822.0 ave      222822 max      222822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222822
Ave neighs/atom = 55.705500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.452463148782, Press = -0.0376623580968902
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  141000   -13152.505   -13152.505   -13294.416   -13294.416    274.53713    274.53713    67331.157    67331.157   -557.72213   -557.72213 
  142000   -13157.743   -13157.743   -13300.451   -13300.451    276.07927    276.07927    67282.689    67282.689   -386.89605   -386.89605 
Loop time of 182.131 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.474 ns/day, 50.592 hours/ns, 5.491 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    | 181.5      | 181.5      | 181.5      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077119   | 0.077119   | 0.077119   |   0.0 |  0.04
Output  | 0.0001881  | 0.0001881  | 0.0001881  |   0.0 |  0.00
Modify  | 0.47988    | 0.47988    | 0.47988    |   0.0 |  0.26
Other   |            | 0.06945    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5698.00 ave        5698 max        5698 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:      222874.0 ave      222874 max      222874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222874
Ave neighs/atom = 55.718500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.43792714441, Press = 0.0327892983891239
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  142000   -13157.743   -13157.743   -13300.451   -13300.451    276.07927    276.07927    67282.689    67282.689   -386.89605   -386.89605 
  143000   -13150.752   -13150.752   -13292.756   -13292.756    274.71674    274.71674    67250.821    67250.821    341.76731    341.76731 
Loop time of 218.48 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.689 hours/ns, 4.577 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    | 217.75     | 217.75     | 217.75     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.090193   | 0.090193   | 0.090193   |   0.0 |  0.04
Output  | 0.00035335 | 0.00035335 | 0.00035335 |   0.0 |  0.00
Modify  | 0.56387    | 0.56387    | 0.56387    |   0.0 |  0.26
Other   |            | 0.07757    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      222626.0 ave      222626 max      222626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222626
Ave neighs/atom = 55.656500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.438252877039, Press = 0.045400229061332
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  143000   -13150.752   -13150.752   -13292.756   -13292.756    274.71674    274.71674    67250.821    67250.821    341.76731    341.76731 
  144000   -13157.416   -13157.416   -13298.115   -13298.115     272.1919     272.1919    67176.842    67176.842    856.02949    856.02949 
Loop time of 222.044 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.679 hours/ns, 4.504 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    | 221.3      | 221.3      | 221.3      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093031   | 0.093031   | 0.093031   |   0.0 |  0.04
Output  | 0.00018692 | 0.00018692 | 0.00018692 |   0.0 |  0.00
Modify  | 0.57502    | 0.57502    | 0.57502    |   0.0 |  0.26
Other   |            | 0.07929    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5728.00 ave        5728 max        5728 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:      223162.0 ave      223162 max      223162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223162
Ave neighs/atom = 55.790500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.437677611137, Press = -0.0708798225892612
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  144000   -13157.416   -13157.416   -13298.115   -13298.115     272.1919     272.1919    67176.842    67176.842    856.02949    856.02949 
  145000   -13154.635   -13154.635   -13296.971   -13296.971    275.35953    275.35953    67174.576    67174.576    898.96172    898.96172 
Loop time of 187.718 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.460 ns/day, 52.144 hours/ns, 5.327 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    | 187.07     | 187.07     | 187.07     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079692   | 0.079692   | 0.079692   |   0.0 |  0.04
Output  | 0.0001114  | 0.0001114  | 0.0001114  |   0.0 |  0.00
Modify  | 0.49322    | 0.49322    | 0.49322    |   0.0 |  0.26
Other   |            | 0.07155    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5729.00 ave        5729 max        5729 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:      223262.0 ave      223262 max      223262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223262
Ave neighs/atom = 55.815500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.420862984638, Press = -0.197766964691535
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  145000   -13154.635   -13154.635   -13296.971   -13296.971    275.35953    275.35953    67174.576    67174.576    898.96172    898.96172 
  146000   -13158.061   -13158.061   -13293.802   -13293.802    262.60118    262.60118    67212.338    67212.338    607.74687    607.74687 
Loop time of 201.902 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.084 hours/ns, 4.953 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    | 201.19     | 201.19     | 201.19     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086494   | 0.086494   | 0.086494   |   0.0 |  0.04
Output  | 0.00038858 | 0.00038858 | 0.00038858 |   0.0 |  0.00
Modify  | 0.5416     | 0.5416     | 0.5416     |   0.0 |  0.27
Other   |            | 0.08073    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      223392.0 ave      223392 max      223392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223392
Ave neighs/atom = 55.848000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.415365540844, Press = -0.30227589267404
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  146000   -13158.061   -13158.061   -13293.802   -13293.802    262.60118    262.60118    67212.338    67212.338    607.74687    607.74687 
  147000   -13147.523   -13147.523   -13293.575   -13293.575    282.54663    282.54663    67317.213    67317.213   -249.06265   -249.06265 
Loop time of 169.085 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.511 ns/day, 46.968 hours/ns, 5.914 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    | 168.5      | 168.5      | 168.5      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07234    | 0.07234    | 0.07234    |   0.0 |  0.04
Output  | 0.00018208 | 0.00018208 | 0.00018208 |   0.0 |  0.00
Modify  | 0.44853    | 0.44853    | 0.44853    |   0.0 |  0.27
Other   |            | 0.06728    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5693.00 ave        5693 max        5693 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:      223650.0 ave      223650 max      223650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223650
Ave neighs/atom = 55.912500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.421663343499, Press = -0.307154330608684
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  147000   -13147.523   -13147.523   -13293.575   -13293.575    282.54663    282.54663    67317.213    67317.213   -249.06265   -249.06265 
  148000    -13155.37    -13155.37   -13294.478   -13294.478    269.11399    269.11399    67324.016    67324.016   -567.88808   -567.88808 
Loop time of 204.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.771 hours/ns, 4.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    | 203.68     | 203.68     | 203.68     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08604    | 0.08604    | 0.08604    |   0.0 |  0.04
Output  | 0.00018557 | 0.00018557 | 0.00018557 |   0.0 |  0.00
Modify  | 0.53512    | 0.53512    | 0.53512    |   0.0 |  0.26
Other   |            | 0.07627    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      223078.0 ave      223078 max      223078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223078
Ave neighs/atom = 55.769500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.427774877566, Press = -0.187876433125163
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  148000    -13155.37    -13155.37   -13294.478   -13294.478    269.11399    269.11399    67324.016    67324.016   -567.88808   -567.88808 
  149000   -13148.587   -13148.587   -13294.953   -13294.953    283.15425    283.15425    67332.029    67332.029   -495.23933   -495.23933 
Loop time of 179.803 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.481 ns/day, 49.945 hours/ns, 5.562 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    | 179.19     | 179.19     | 179.19     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075374   | 0.075374   | 0.075374   |   0.0 |  0.04
Output  | 0.00018178 | 0.00018178 | 0.00018178 |   0.0 |  0.00
Modify  | 0.47001    | 0.47001    | 0.47001    |   0.0 |  0.26
Other   |            | 0.06832    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5730.00 ave        5730 max        5730 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:      223054.0 ave      223054 max      223054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223054
Ave neighs/atom = 55.763500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.433434004556, Press = -0.0835339683692796
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  149000   -13148.587   -13148.587   -13294.953   -13294.953    283.15425    283.15425    67332.029    67332.029   -495.23933   -495.23933 
  150000   -13155.689   -13155.689   -13298.266   -13298.266     275.8256     275.8256    67279.507    67279.507   -146.90765   -146.90765 
Loop time of 171.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.505 ns/day, 47.539 hours/ns, 5.843 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.54     | 170.54     | 170.54     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073295   | 0.073295   | 0.073295   |   0.0 |  0.04
Output  | 0.0001945  | 0.0001945  | 0.0001945  |   0.0 |  0.00
Modify  | 0.45692    | 0.45692    | 0.45692    |   0.0 |  0.27
Other   |            | 0.06946    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5681.00 ave        5681 max        5681 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:      222708.0 ave      222708 max      222708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222708
Ave neighs/atom = 55.677000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.439653930269, Press = -0.0454367016801781
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  150000   -13155.689   -13155.689   -13298.266   -13298.266     275.8256     275.8256    67279.507    67279.507   -146.90765   -146.90765 
  151000   -13153.079   -13153.079   -13296.376   -13296.376    277.21815    277.21815    67277.916    67277.916   -46.654001   -46.654001 
Loop time of 175.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.492 ns/day, 48.813 hours/ns, 5.691 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    | 175.12     | 175.12     | 175.12     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074506   | 0.074506   | 0.074506   |   0.0 |  0.04
Output  | 0.00039379 | 0.00039379 | 0.00039379 |   0.0 |  0.00
Modify  | 0.46459    | 0.46459    | 0.46459    |   0.0 |  0.26
Other   |            | 0.06906    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5721.00 ave        5721 max        5721 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:      222908.0 ave      222908 max      222908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222908
Ave neighs/atom = 55.727000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.442513606176, Press = -0.0753655049739238
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  151000   -13153.079   -13153.079   -13296.376   -13296.376    277.21815    277.21815    67277.916    67277.916   -46.654001   -46.654001 
  152000   -13158.929   -13158.929   -13296.885   -13296.885    266.88509    266.88509    67243.108    67243.108    226.31864    226.31864 
Loop time of 137.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.626 ns/day, 38.328 hours/ns, 7.247 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    | 137.49     | 137.49     | 137.49     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060532   | 0.060532   | 0.060532   |   0.0 |  0.04
Output  | 0.00023883 | 0.00023883 | 0.00023883 |   0.0 |  0.00
Modify  | 0.373      | 0.373      | 0.373      |   0.0 |  0.27
Other   |            | 0.05735    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5678.00 ave        5678 max        5678 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:      223148.0 ave      223148 max      223148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223148
Ave neighs/atom = 55.787000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.430355512778, Press = -0.0896855627556347
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  152000   -13158.929   -13158.929   -13296.885   -13296.885    266.88509    266.88509    67243.108    67243.108    226.31864    226.31864 
  153000   -13156.523   -13156.523   -13295.314   -13295.314    268.50087    268.50087    67237.197    67237.197    389.73136    389.73136 
Loop time of 117.68 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.734 ns/day, 32.689 hours/ns, 8.498 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    | 117.27     | 117.27     | 117.27     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049757   | 0.049757   | 0.049757   |   0.0 |  0.04
Output  | 0.00022174 | 0.00022174 | 0.00022174 |   0.0 |  0.00
Modify  | 0.31053    | 0.31053    | 0.31053    |   0.0 |  0.26
Other   |            | 0.04559    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5713.00 ave        5713 max        5713 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:      223036.0 ave      223036 max      223036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223036
Ave neighs/atom = 55.759000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.429976286675, Press = -0.153283329572498
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  153000   -13156.523   -13156.523   -13295.314   -13295.314    268.50087    268.50087    67237.197    67237.197    389.73136    389.73136 
  154000   -13155.181   -13155.181   -13296.343   -13296.343    273.08718    273.08718    67218.805    67218.805    616.99031    616.99031 
Loop time of 129.267 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.668 ns/day, 35.907 hours/ns, 7.736 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.82     | 128.82     | 128.82     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055082   | 0.055082   | 0.055082   |   0.0 |  0.04
Output  | 9.944e-05  | 9.944e-05  | 9.944e-05  |   0.0 |  0.00
Modify  | 0.34205    | 0.34205    | 0.34205    |   0.0 |  0.26
Other   |            | 0.05118    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5699.00 ave        5699 max        5699 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:      223272.0 ave      223272 max      223272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223272
Ave neighs/atom = 55.818000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.424114496421, Press = -0.197103827638647
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  154000   -13155.181   -13155.181   -13296.343   -13296.343    273.08718    273.08718    67218.805    67218.805    616.99031    616.99031 
  155000   -13153.805   -13153.805   -13296.521   -13296.521    276.09301    276.09301    67248.565    67248.565    301.69237    301.69237 
Loop time of 197.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.962 hours/ns, 5.054 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    | 197.18     | 197.18     | 197.18     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083399   | 0.083399   | 0.083399   |   0.0 |  0.04
Output  | 0.0001824  | 0.0001824  | 0.0001824  |   0.0 |  0.00
Modify  | 0.52339    | 0.52339    | 0.52339    |   0.0 |  0.26
Other   |            | 0.0758     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5738.00 ave        5738 max        5738 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:      222954.0 ave      222954 max      222954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222954
Ave neighs/atom = 55.738500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.431079279438, Press = -0.352400670077989
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  155000   -13153.805   -13153.805   -13296.521   -13296.521    276.09301    276.09301    67248.565    67248.565    301.69237    301.69237 
  156000   -13149.675   -13149.675   -13293.419   -13293.419    278.08255    278.08255    67320.599    67320.599   -379.03575   -379.03575 
Loop time of 178.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.485 ns/day, 49.462 hours/ns, 5.616 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    | 177.44     | 177.44     | 177.44     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076631   | 0.076631   | 0.076631   |   0.0 |  0.04
Output  | 0.0012937  | 0.0012937  | 0.0012937  |   0.0 |  0.00
Modify  | 0.475      | 0.475      | 0.475      |   0.0 |  0.27
Other   |            | 0.07073    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      222866.0 ave      222866 max      222866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222866
Ave neighs/atom = 55.716500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.431413673016, Press = -0.347311749501671
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  156000   -13149.675   -13149.675   -13293.419   -13293.419    278.08255    278.08255    67320.599    67320.599   -379.03575   -379.03575 
  157000   -13156.195   -13156.195   -13295.495   -13295.495    269.48537    269.48537    67360.981    67360.981   -943.66884   -943.66884 
Loop time of 168.618 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.512 ns/day, 46.838 hours/ns, 5.931 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    | 168.01     | 168.01     | 168.01     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073363   | 0.073363   | 0.073363   |   0.0 |  0.04
Output  | 0.00022048 | 0.00022048 | 0.00022048 |   0.0 |  0.00
Modify  | 0.45887    | 0.45887    | 0.45887    |   0.0 |  0.27
Other   |            | 0.07135    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5710.00 ave        5710 max        5710 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:      223004.0 ave      223004 max      223004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223004
Ave neighs/atom = 55.751000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.439673519218, Press = -0.321201307134942
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  157000   -13156.195   -13156.195   -13295.495   -13295.495    269.48537    269.48537    67360.981    67360.981   -943.66884   -943.66884 
  158000   -13151.357   -13151.357   -13293.375   -13293.375    274.74306    274.74306    67443.684    67443.684   -1720.3542   -1720.3542 
Loop time of 123.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.700 ns/day, 34.263 hours/ns, 8.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    | 122.92     | 122.92     | 122.92     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052711   | 0.052711   | 0.052711   |   0.0 |  0.04
Output  | 0.00018967 | 0.00018967 | 0.00018967 |   0.0 |  0.00
Modify  | 0.32857    | 0.32857    | 0.32857    |   0.0 |  0.27
Other   |            | 0.04847    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5656.00 ave        5656 max        5656 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:      222884.0 ave      222884 max      222884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222884
Ave neighs/atom = 55.721000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.446957072036, Press = -0.0860247222052033
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  158000   -13151.357   -13151.357   -13293.375   -13293.375    274.74306    274.74306    67443.684    67443.684   -1720.3542   -1720.3542 
  159000   -13156.188   -13156.188   -13296.521   -13296.521    271.48315    271.48315    67318.058    67318.058   -479.63614   -479.63614 
Loop time of 134.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.641 ns/day, 37.439 hours/ns, 7.420 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    | 134.31     | 134.31     | 134.31     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058357   | 0.058357   | 0.058357   |   0.0 |  0.04
Output  | 9.7857e-05 | 9.7857e-05 | 9.7857e-05 |   0.0 |  0.00
Modify  | 0.36158    | 0.36158    | 0.36158    |   0.0 |  0.27
Other   |            | 0.0536     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5726.00 ave        5726 max        5726 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:      222674.0 ave      222674 max      222674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222674
Ave neighs/atom = 55.668500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.444386026116, Press = 0.0179472749593323
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  159000   -13156.188   -13156.188   -13296.521   -13296.521    271.48315    271.48315    67318.058    67318.058   -479.63614   -479.63614 
  160000   -13149.333   -13149.333    -13291.54    -13291.54    275.11037    275.11037    67298.749    67298.749    100.64744    100.64744 
Loop time of 116.394 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.742 ns/day, 32.332 hours/ns, 8.592 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    | 115.99     | 115.99     | 115.99     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048974   | 0.048974   | 0.048974   |   0.0 |  0.04
Output  | 0.00010097 | 0.00010097 | 0.00010097 |   0.0 |  0.00
Modify  | 0.30635    | 0.30635    | 0.30635    |   0.0 |  0.26
Other   |            | 0.04488    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5735.00 ave        5735 max        5735 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:      222730.0 ave      222730 max      222730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222730
Ave neighs/atom = 55.682500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.449352748483, Press = -0.0479448991271409
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  160000   -13149.333   -13149.333    -13291.54    -13291.54    275.11037    275.11037    67298.749    67298.749    100.64744    100.64744 
  161000   -13154.993   -13154.993   -13296.607   -13296.607    273.96058    273.96058    67221.672    67221.672    461.50718    461.50718 
Loop time of 132.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.650 ns/day, 36.917 hours/ns, 7.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.44     | 132.44     | 132.44     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057428   | 0.057428   | 0.057428   |   0.0 |  0.04
Output  | 0.00010054 | 0.00010054 | 0.00010054 |   0.0 |  0.00
Modify  | 0.35433    | 0.35433    | 0.35433    |   0.0 |  0.27
Other   |            | 0.05224    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5703.00 ave        5703 max        5703 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:      223128.0 ave      223128 max      223128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223128
Ave neighs/atom = 55.782000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454818728436, Press = -0.0693736480290565
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  161000   -13154.993   -13154.993   -13296.607   -13296.607    273.96058    273.96058    67221.672    67221.672    461.50718    461.50718 
  162000    -13153.62    -13153.62   -13295.825   -13295.825    275.10506    275.10506    67201.481    67201.481    846.47628    846.47628 
Loop time of 116.238 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.743 ns/day, 32.288 hours/ns, 8.603 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    | 115.84     | 115.84     | 115.84     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048552   | 0.048552   | 0.048552   |   0.0 |  0.04
Output  | 9.5802e-05 | 9.5802e-05 | 9.5802e-05 |   0.0 |  0.00
Modify  | 0.30451    | 0.30451    | 0.30451    |   0.0 |  0.26
Other   |            | 0.04439    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5720.00 ave        5720 max        5720 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:      223212.0 ave      223212 max      223212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223212
Ave neighs/atom = 55.803000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.458187247214, Press = -0.185967303603626
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  162000    -13153.62    -13153.62   -13295.825   -13295.825    275.10506    275.10506    67201.481    67201.481    846.47628    846.47628 
  163000   -13153.859   -13153.859   -13293.189   -13293.189    269.54349    269.54349    67159.368    67159.368    1368.0274    1368.0274 
Loop time of 122.196 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.707 ns/day, 33.943 hours/ns, 8.184 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    | 121.77     | 121.77     | 121.77     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052088   | 0.052088   | 0.052088   |   0.0 |  0.04
Output  | 0.00011203 | 0.00011203 | 0.00011203 |   0.0 |  0.00
Modify  | 0.32145    | 0.32145    | 0.32145    |   0.0 |  0.26
Other   |            | 0.04736    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5750.00 ave        5750 max        5750 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:      223184.0 ave      223184 max      223184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223184
Ave neighs/atom = 55.796000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.453686240946, Press = -0.389284823375102
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  163000   -13153.859   -13153.859   -13293.189   -13293.189    269.54349    269.54349    67159.368    67159.368    1368.0274    1368.0274 
  164000   -13152.281   -13152.281   -13296.178   -13296.178    278.37759    278.37759     67270.56     67270.56    29.593294    29.593294 
Loop time of 128.02 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.561 hours/ns, 7.811 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    | 127.58     | 127.58     | 127.58     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054642   | 0.054642   | 0.054642   |   0.0 |  0.04
Output  | 0.00025558 | 0.00025558 | 0.00025558 |   0.0 |  0.00
Modify  | 0.33879    | 0.33879    | 0.33879    |   0.0 |  0.26
Other   |            | 0.05089    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5710.00 ave        5710 max        5710 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:      223656.0 ave      223656 max      223656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223656
Ave neighs/atom = 55.914000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.451429419751, Press = -0.4334974068789
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  164000   -13152.281   -13152.281   -13296.178   -13296.178    278.37759    278.37759     67270.56     67270.56    29.593294    29.593294 
  165000   -13157.687   -13157.687   -13298.432   -13298.432    272.28071    272.28071    67306.421    67306.421   -474.37109   -474.37109 
Loop time of 127.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.679 ns/day, 35.336 hours/ns, 7.861 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    | 126.77     | 126.77     | 126.77     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05451    | 0.05451    | 0.05451    |   0.0 |  0.04
Output  | 0.00010503 | 0.00010503 | 0.00010503 |   0.0 |  0.00
Modify  | 0.33866    | 0.33866    | 0.33866    |   0.0 |  0.27
Other   |            | 0.0512     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5680.00 ave        5680 max        5680 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:      223290.0 ave      223290 max      223290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223290
Ave neighs/atom = 55.822500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.446596236446, Press = -0.270642103225929
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  165000   -13157.687   -13157.687   -13298.432   -13298.432    272.28071    272.28071    67306.421    67306.421   -474.37109   -474.37109 
  166000   -13153.757   -13153.757   -13294.668   -13294.668    272.60263    272.60263    67343.931    67343.931   -689.70679   -689.70679 
Loop time of 128.311 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.642 hours/ns, 7.794 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    | 127.86     | 127.86     | 127.86     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055161   | 0.055161   | 0.055161   |   0.0 |  0.04
Output  | 0.00017649 | 0.00017649 | 0.00017649 |   0.0 |  0.00
Modify  | 0.34283    | 0.34283    | 0.34283    |   0.0 |  0.27
Other   |            | 0.05141    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5709.00 ave        5709 max        5709 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:      222870.0 ave      222870 max      222870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222870
Ave neighs/atom = 55.717500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.452939848903, Press = -0.135879574601562
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  166000   -13153.757   -13153.757   -13294.668   -13294.668    272.60263    272.60263    67343.931    67343.931   -689.70679   -689.70679 
  167000   -13153.128   -13153.128   -13294.969   -13294.969    274.40035    274.40035    67346.178    67346.178   -696.63363   -696.63363 
Loop time of 122.14 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.707 ns/day, 33.928 hours/ns, 8.187 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.72     | 121.72     | 121.72     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051682   | 0.051682   | 0.051682   |   0.0 |  0.04
Output  | 0.0001053  | 0.0001053  | 0.0001053  |   0.0 |  0.00
Modify  | 0.3213     | 0.3213     | 0.3213     |   0.0 |  0.26
Other   |            | 0.04757    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5720.00 ave        5720 max        5720 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:      223018.0 ave      223018 max      223018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223018
Ave neighs/atom = 55.754500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454434702361, Press = -0.0296535464033419
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  167000   -13153.128   -13153.128   -13294.969   -13294.969    274.40035    274.40035    67346.178    67346.178   -696.63363   -696.63363 
  168000   -13155.868   -13155.868   -13296.248   -13296.248    271.57399    271.57399    67294.519    67294.519   -290.14714   -290.14714 
Loop time of 123.706 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.698 ns/day, 34.363 hours/ns, 8.084 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    | 123.28     | 123.28     | 123.28     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052681   | 0.052681   | 0.052681   |   0.0 |  0.04
Output  | 0.0001049  | 0.0001049  | 0.0001049  |   0.0 |  0.00
Modify  | 0.3275     | 0.3275     | 0.3275     |   0.0 |  0.26
Other   |            | 0.04895    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5690.00 ave        5690 max        5690 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:      222992.0 ave      222992 max      222992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222992
Ave neighs/atom = 55.748000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.463084139128, Press = 0.0620132701263614
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  168000   -13155.868   -13155.868   -13296.248   -13296.248    271.57399    271.57399    67294.519    67294.519   -290.14714   -290.14714 
  169000   -13150.366   -13150.366   -13294.013   -13294.013    277.89605    277.89605    67234.971    67234.971    568.75376    568.75376 
Loop time of 119.96 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.720 ns/day, 33.322 hours/ns, 8.336 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    | 119.55     | 119.55     | 119.55     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050449   | 0.050449   | 0.050449   |   0.0 |  0.04
Output  | 0.0001038  | 0.0001038  | 0.0001038  |   0.0 |  0.00
Modify  | 0.31595    | 0.31595    | 0.31595    |   0.0 |  0.26
Other   |            | 0.04658    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5732.00 ave        5732 max        5732 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:      222894.0 ave      222894 max      222894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222894
Ave neighs/atom = 55.723500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.467428591486, Press = 0.133565978799368
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  169000   -13150.366   -13150.366   -13294.013   -13294.013    277.89605    277.89605    67234.971    67234.971    568.75376    568.75376 
  170000   -13153.356   -13153.356   -13294.202   -13294.202    272.47649    272.47649    67196.562    67196.562     904.3122     904.3122 
Loop time of 136.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.635 ns/day, 37.804 hours/ns, 7.348 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    | 135.61     | 135.61     | 135.61     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058622   | 0.058622   | 0.058622   |   0.0 |  0.04
Output  | 0.00010412 | 0.00010412 | 0.00010412 |   0.0 |  0.00
Modify  | 0.36353    | 0.36353    | 0.36353    |   0.0 |  0.27
Other   |            | 0.0562     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5694.00 ave        5694 max        5694 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:      223128.0 ave      223128 max      223128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223128
Ave neighs/atom = 55.782000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.463575420703, Press = 0.0251667869256149
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  170000   -13153.356   -13153.356   -13294.202   -13294.202    272.47649    272.47649    67196.562    67196.562     904.3122     904.3122 
  171000    -13155.38    -13155.38   -13298.045   -13298.045    275.99545    275.99545    67224.823    67224.823    436.31356    436.31356 
Loop time of 119.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.723 ns/day, 33.179 hours/ns, 8.372 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.03     | 119.03     | 119.03     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050658   | 0.050658   | 0.050658   |   0.0 |  0.04
Output  | 0.0001058  | 0.0001058  | 0.0001058  |   0.0 |  0.00
Modify  | 0.31493    | 0.31493    | 0.31493    |   0.0 |  0.26
Other   |            | 0.04739    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5728.00 ave        5728 max        5728 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:      223324.0 ave      223324 max      223324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223324
Ave neighs/atom = 55.831000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.456937076767, Press = -0.130366191441355
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  171000    -13155.38    -13155.38   -13298.045   -13298.045    275.99545    275.99545    67224.823    67224.823    436.31356    436.31356 
  172000   -13150.686   -13150.686   -13294.371   -13294.371    277.96798    277.96798    67267.585    67267.585    174.44545    174.44545 
Loop time of 122.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.707 ns/day, 33.944 hours/ns, 8.184 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    | 121.78     | 121.78     | 121.78     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051697   | 0.051697   | 0.051697   |   0.0 |  0.04
Output  | 9.3171e-05 | 9.3171e-05 | 9.3171e-05 |   0.0 |  0.00
Modify  | 0.32187    | 0.32187    | 0.32187    |   0.0 |  0.26
Other   |            | 0.04743    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5744.00 ave        5744 max        5744 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:      223120.0 ave      223120 max      223120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223120
Ave neighs/atom = 55.780000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.45500100817, Press = -0.175082941106107
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  172000   -13150.686   -13150.686   -13294.371   -13294.371    277.96798    277.96798    67267.585    67267.585    174.44545    174.44545 
  173000   -13155.459   -13155.459    -13295.28    -13295.28    270.49246    270.49246    67279.633    67279.633   -8.1381817   -8.1381817 
Loop time of 126.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.684 ns/day, 35.111 hours/ns, 7.911 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    | 125.96     | 125.96     | 125.96     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053261   | 0.053261   | 0.053261   |   0.0 |  0.04
Output  | 0.00010293 | 0.00010293 | 0.00010293 |   0.0 |  0.00
Modify  | 0.33289    | 0.33289    | 0.33289    |   0.0 |  0.26
Other   |            | 0.04945    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5713.00 ave        5713 max        5713 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:      223132.0 ave      223132 max      223132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223132
Ave neighs/atom = 55.783000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.456744245265, Press = -0.231650605702953
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  173000   -13155.459   -13155.459    -13295.28    -13295.28    270.49246    270.49246    67279.633    67279.633   -8.1381817   -8.1381817 
  174000   -13154.533   -13154.533   -13294.101   -13294.101    270.00469    270.00469    67401.163    67401.163   -1313.2082   -1313.2082 
Loop time of 119.432 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.723 ns/day, 33.176 hours/ns, 8.373 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    | 119.02     | 119.02     | 119.02     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050012   | 0.050012   | 0.050012   |   0.0 |  0.04
Output  | 0.00010541 | 0.00010541 | 0.00010541 |   0.0 |  0.00
Modify  | 0.31456    | 0.31456    | 0.31456    |   0.0 |  0.26
Other   |            | 0.04621    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5715.00 ave        5715 max        5715 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:      222998.0 ave      222998 max      222998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222998
Ave neighs/atom = 55.749500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.466810671865, Press = -0.363154925408664
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  174000   -13154.533   -13154.533   -13294.101   -13294.101    270.00469    270.00469    67401.163    67401.163   -1313.2082   -1313.2082 
  175000   -13150.982   -13150.982   -13294.082   -13294.082    276.83562    276.83562    67423.428    67423.428   -1513.9304   -1513.9304 
Loop time of 118.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.730 ns/day, 32.889 hours/ns, 8.446 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    | 117.99     | 117.99     | 117.99     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050318   | 0.050318   | 0.050318   |   0.0 |  0.04
Output  | 0.00010897 | 0.00010897 | 0.00010897 |   0.0 |  0.00
Modify  | 0.31445    | 0.31445    | 0.31445    |   0.0 |  0.27
Other   |            | 0.04698    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      222692.0 ave      222692 max      222692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222692
Ave neighs/atom = 55.673000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.46579533938, Press = -0.120427693912718
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  175000   -13150.982   -13150.982   -13294.082   -13294.082    276.83562    276.83562    67423.428    67423.428   -1513.9304   -1513.9304 
  176000   -13154.849   -13154.849   -13293.732   -13293.732    268.67747    268.67747    67328.705    67328.705   -494.19373   -494.19373 
Loop time of 130.075 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.664 ns/day, 36.132 hours/ns, 7.688 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    | 129.62     | 129.62     | 129.62     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055238   | 0.055238   | 0.055238   |   0.0 |  0.04
Output  | 0.00037962 | 0.00037962 | 0.00037962 |   0.0 |  0.00
Modify  | 0.3444     | 0.3444     | 0.3444     |   0.0 |  0.26
Other   |            | 0.05126    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5662.00 ave        5662 max        5662 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:      222598.0 ave      222598 max      222598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222598
Ave neighs/atom = 55.649500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.466964700099, Press = -0.026647691046896
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  176000   -13154.849   -13154.849   -13293.732   -13293.732    268.67747    268.67747    67328.705    67328.705   -494.19373   -494.19373 
  177000   -13150.959   -13150.959   -13293.967   -13293.967    276.65849    276.65849    67304.026    67304.026   -218.90827   -218.90827 
Loop time of 130.523 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.662 ns/day, 36.256 hours/ns, 7.661 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    | 130.07     | 130.07     | 130.07     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05547    | 0.05547    | 0.05547    |   0.0 |  0.04
Output  | 0.00010529 | 0.00010529 | 0.00010529 |   0.0 |  0.00
Modify  | 0.34543    | 0.34543    | 0.34543    |   0.0 |  0.26
Other   |            | 0.0507     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5691.00 ave        5691 max        5691 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:      223018.0 ave      223018 max      223018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223018
Ave neighs/atom = 55.754500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.473595167488, Press = 0.00552989408256606
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  177000   -13150.959   -13150.959   -13293.967   -13293.967    276.65849    276.65849    67304.026    67304.026   -218.90827   -218.90827 
  178000   -13155.564   -13155.564   -13296.007   -13296.007    271.69661    271.69661    67247.987    67247.987    295.82044    295.82044 
Loop time of 125.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.854 hours/ns, 7.970 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    | 125.04     | 125.04     | 125.04     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053135   | 0.053135   | 0.053135   |   0.0 |  0.04
Output  | 0.00010223 | 0.00010223 | 0.00010223 |   0.0 |  0.00
Modify  | 0.33084    | 0.33084    | 0.33084    |   0.0 |  0.26
Other   |            | 0.04987    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5713.00 ave        5713 max        5713 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:      223062.0 ave      223062 max      223062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223062
Ave neighs/atom = 55.765500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.467932613674, Press = 0.0188737807352291
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  178000   -13155.564   -13155.564   -13296.007   -13296.007    271.69661    271.69661    67247.987    67247.987    295.82044    295.82044 
  179000   -13152.457   -13152.457    -13295.74    -13295.74    277.19102    277.19102    67180.265    67180.265    992.93608    992.93608 
Loop time of 135.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.637 ns/day, 37.701 hours/ns, 7.368 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    | 135.26     | 135.26     | 135.26     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057453   | 0.057453   | 0.057453   |   0.0 |  0.04
Output  | 0.00010396 | 0.00010396 | 0.00010396 |   0.0 |  0.00
Modify  | 0.35652    | 0.35652    | 0.35652    |   0.0 |  0.26
Other   |            | 0.05281    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      222904.0 ave      222904 max      222904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222904
Ave neighs/atom = 55.726000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.474692072064, Press = 0.0506737537850195
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  179000   -13152.457   -13152.457    -13295.74    -13295.74    277.19102    277.19102    67180.265    67180.265    992.93608    992.93608 
  180000   -13151.288   -13151.288   -13295.057   -13295.057    278.13169    278.13169    67120.114    67120.114    1718.4649    1718.4649 
Loop time of 128.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.670 ns/day, 35.810 hours/ns, 7.757 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.46     | 128.46     | 128.46     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055939   | 0.055939   | 0.055939   |   0.0 |  0.04
Output  | 0.00010151 | 0.00010151 | 0.00010151 |   0.0 |  0.00
Modify  | 0.34376    | 0.34376    | 0.34376    |   0.0 |  0.27
Other   |            | 0.05221    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5719.00 ave        5719 max        5719 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:      223278.0 ave      223278 max      223278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223278
Ave neighs/atom = 55.819500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.474383309538, Press = -0.0956765364016832
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  180000   -13151.288   -13151.288   -13295.057   -13295.057    278.13169    278.13169    67120.114    67120.114    1718.4649    1718.4649 
  181000   -13156.557   -13156.557   -13295.847   -13295.847     269.4644     269.4644    67205.089    67205.089    675.19447    675.19447 
Loop time of 119.74 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.722 ns/day, 33.261 hours/ns, 8.351 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    | 119.33     | 119.33     | 119.33     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050641   | 0.050641   | 0.050641   |   0.0 |  0.04
Output  | 0.00010186 | 0.00010186 | 0.00010186 |   0.0 |  0.00
Modify  | 0.31468    | 0.31468    | 0.31468    |   0.0 |  0.26
Other   |            | 0.04618    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5743.00 ave        5743 max        5743 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:      223608.0 ave      223608 max      223608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223608
Ave neighs/atom = 55.902000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.464352966465, Press = -0.215804941834251
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  181000   -13156.557   -13156.557   -13295.847   -13295.847     269.4644     269.4644    67205.089    67205.089    675.19447    675.19447 
  182000   -13154.573   -13154.573   -13296.155   -13296.155    273.90046    273.90046    67275.357    67275.357   -23.644575   -23.644575 
Loop time of 134.189 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.644 ns/day, 37.275 hours/ns, 7.452 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    | 133.72     | 133.72     | 133.72     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056923   | 0.056923   | 0.056923   |   0.0 |  0.04
Output  | 0.00010444 | 0.00010444 | 0.00010444 |   0.0 |  0.00
Modify  | 0.35431    | 0.35431    | 0.35431    |   0.0 |  0.26
Other   |            | 0.05253    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5711.00 ave        5711 max        5711 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:      223196.0 ave      223196 max      223196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223196
Ave neighs/atom = 55.799000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.457239610764, Press = -0.222611833301592
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  182000   -13154.573   -13154.573   -13296.155   -13296.155    273.90046    273.90046    67275.357    67275.357   -23.644575   -23.644575 
  183000   -13157.192   -13157.192   -13297.837   -13297.837    272.08615    272.08615    67312.258    67312.258   -525.05986   -525.05986 
Loop time of 192.745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.540 hours/ns, 5.188 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    | 192.08     | 192.08     | 192.08     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08169    | 0.08169    | 0.08169    |   0.0 |  0.04
Output  | 0.00018172 | 0.00018172 | 0.00018172 |   0.0 |  0.00
Modify  | 0.51143    | 0.51143    | 0.51143    |   0.0 |  0.27
Other   |            | 0.07397    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      223054.0 ave      223054 max      223054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223054
Ave neighs/atom = 55.763500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.44276168297, Press = -0.173655301771286
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  183000   -13157.192   -13157.192   -13297.837   -13297.837    272.08615    272.08615    67312.258    67312.258   -525.05986   -525.05986 
  184000   -13154.192   -13154.192   -13295.783   -13295.783    273.91691    273.91691    67385.588    67385.588    -1137.999    -1137.999 
Loop time of 230.335 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 63.982 hours/ns, 4.342 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    | 229.55     | 229.55     | 229.55     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09647    | 0.09647    | 0.09647    |   0.0 |  0.04
Output  | 0.00031046 | 0.00031046 | 0.00031046 |   0.0 |  0.00
Modify  | 0.60798    | 0.60798    | 0.60798    |   0.0 |  0.26
Other   |            | 0.08422    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5750.00 ave        5750 max        5750 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:      222612.0 ave      222612 max      222612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222612
Ave neighs/atom = 55.653000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.439115655446, Press = -0.0731668422792967
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  184000   -13154.192   -13154.192   -13295.783   -13295.783    273.91691    273.91691    67385.588    67385.588    -1137.999    -1137.999 
  185000   -13154.396   -13154.396   -13298.302   -13298.302    278.39528    278.39528    67379.028    67379.028   -1224.4248   -1224.4248 
Loop time of 200.277 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.633 hours/ns, 4.993 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    | 199.59     | 199.59     | 199.59     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084001   | 0.084001   | 0.084001   |   0.0 |  0.04
Output  | 0.00037653 | 0.00037653 | 0.00037653 |   0.0 |  0.00
Modify  | 0.53084    | 0.53084    | 0.53084    |   0.0 |  0.27
Other   |            | 0.07555    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      222522.0 ave      222522 max      222522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222522
Ave neighs/atom = 55.630500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.428961673476, Press = 0.230118888523716
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  185000   -13154.396   -13154.396   -13298.302   -13298.302    278.39528    278.39528    67379.028    67379.028   -1224.4248   -1224.4248 
  186000   -13156.206   -13156.206   -13297.659   -13297.659    273.65049    273.65049    67243.789    67243.789    233.99597    233.99597 
Loop time of 171.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.503 ns/day, 47.725 hours/ns, 5.820 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    | 171.21     | 171.21     | 171.21     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073623   | 0.073623   | 0.073623   |   0.0 |  0.04
Output  | 9.4855e-05 | 9.4855e-05 | 9.4855e-05 |   0.0 |  0.00
Modify  | 0.4623     | 0.4623     | 0.4623     |   0.0 |  0.27
Other   |            | 0.06788    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5728.00 ave        5728 max        5728 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:      222458.0 ave      222458 max      222458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222458
Ave neighs/atom = 55.614500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.429632835967, Press = 0.0760875831186329
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  186000   -13156.206   -13156.206   -13297.659   -13297.659    273.65049    273.65049    67243.789    67243.789    233.99597    233.99597 
  187000   -13151.019   -13151.019   -13291.578   -13291.578    271.92089    271.92089    67232.174    67232.174    650.88093    650.88093 
Loop time of 122.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.703 ns/day, 34.163 hours/ns, 8.131 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    | 122.56     | 122.56     | 122.56     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052349   | 0.052349   | 0.052349   |   0.0 |  0.04
Output  | 0.00018876 | 0.00018876 | 0.00018876 |   0.0 |  0.00
Modify  | 0.32663    | 0.32663    | 0.32663    |   0.0 |  0.27
Other   |            | 0.04807    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5727.00 ave        5727 max        5727 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:      222764.0 ave      222764 max      222764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222764
Ave neighs/atom = 55.691000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.43557918582, Press = 0.00666794737302164
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  187000   -13151.019   -13151.019   -13291.578   -13291.578    271.92089    271.92089    67232.174    67232.174    650.88093    650.88093 
  188000   -13156.821   -13156.821    -13295.83    -13295.83    268.92215    268.92215    67179.818    67179.818    905.71522    905.71522 
Loop time of 122.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.707 ns/day, 33.927 hours/ns, 8.188 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    | 121.71     | 121.71     | 121.71     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051935   | 0.051935   | 0.051935   |   0.0 |  0.04
Output  | 0.00010459 | 0.00010459 | 0.00010459 |   0.0 |  0.00
Modify  | 0.32317    | 0.32317    | 0.32317    |   0.0 |  0.26
Other   |            | 0.04754    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      223388.0 ave      223388 max      223388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223388
Ave neighs/atom = 55.847000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.427660730729, Press = -0.0888154721124764
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  188000   -13156.821   -13156.821    -13295.83    -13295.83    268.92215    268.92215    67179.818    67179.818    905.71522    905.71522 
  189000   -13152.048   -13152.048   -13294.438   -13294.438    275.46191    275.46191    67216.472    67216.472    705.44035    705.44035 
Loop time of 135.605 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.637 ns/day, 37.668 hours/ns, 7.374 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    | 135.13     | 135.13     | 135.13     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058047   | 0.058047   | 0.058047   |   0.0 |  0.04
Output  | 0.00019505 | 0.00019505 | 0.00019505 |   0.0 |  0.00
Modify  | 0.3612     | 0.3612     | 0.3612     |   0.0 |  0.27
Other   |            | 0.05316    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5680.00 ave        5680 max        5680 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:      223344.0 ave      223344 max      223344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223344
Ave neighs/atom = 55.836000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.418501867565, Press = -0.203946258659061
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  189000   -13152.048   -13152.048   -13294.438   -13294.438    275.46191    275.46191    67216.472    67216.472    705.44035    705.44035 
  190000    -13157.79    -13157.79   -13296.634   -13296.634    268.60262    268.60262    67252.558    67252.558     121.7962     121.7962 
Loop time of 182.543 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.473 ns/day, 50.707 hours/ns, 5.478 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    | 181.9      | 181.9      | 181.9      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078875   | 0.078875   | 0.078875   |   0.0 |  0.04
Output  | 0.00031417 | 0.00031417 | 0.00031417 |   0.0 |  0.00
Modify  | 0.48869    | 0.48869    | 0.48869    |   0.0 |  0.27
Other   |            | 0.07402    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5705.00 ave        5705 max        5705 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:      223146.0 ave      223146 max      223146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223146
Ave neighs/atom = 55.786500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.413499578758, Press = -0.213732999554311
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  190000    -13157.79    -13157.79   -13296.634   -13296.634    268.60262    268.60262    67252.558    67252.558     121.7962     121.7962 
  191000   -13153.372   -13153.372   -13295.276   -13295.276    274.52283    274.52283    67295.966    67295.966   -163.40418   -163.40418 
Loop time of 213.231 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.231 hours/ns, 4.690 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    | 212.49     | 212.49     | 212.49     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.090355   | 0.090355   | 0.090355   |   0.0 |  0.04
Output  | 0.00018    | 0.00018    | 0.00018    |   0.0 |  0.00
Modify  | 0.57098    | 0.57098    | 0.57098    |   0.0 |  0.27
Other   |            | 0.08156    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5737.00 ave        5737 max        5737 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:      222856.0 ave      222856 max      222856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222856
Ave neighs/atom = 55.714000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.404826057835, Press = -0.148751810851261
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  191000   -13153.372   -13153.372   -13295.276   -13295.276    274.52283    274.52283    67295.966    67295.966   -163.40418   -163.40418 
  192000   -13157.535   -13157.535   -13299.439   -13299.439     274.5233     274.5233     67292.52     67292.52   -372.75338   -372.75338 
Loop time of 228.559 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.489 hours/ns, 4.375 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    | 227.78     | 227.78     | 227.78     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095048   | 0.095048   | 0.095048   |   0.0 |  0.04
Output  | 0.00031673 | 0.00031673 | 0.00031673 |   0.0 |  0.00
Modify  | 0.6016     | 0.6016     | 0.6016     |   0.0 |  0.26
Other   |            | 0.08319    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5734.00 ave        5734 max        5734 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:      222920.0 ave      222920 max      222920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222920
Ave neighs/atom = 55.730000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.402516517442, Press = -0.117985382341782
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  192000   -13157.535   -13157.535   -13299.439   -13299.439     274.5233     274.5233     67292.52     67292.52   -372.75338   -372.75338 
  193000   -13153.514   -13153.514   -13295.347   -13295.347    274.38655    274.38655     67344.73     67344.73   -685.49955   -685.49955 
Loop time of 200.544 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.707 hours/ns, 4.986 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    | 199.85     | 199.85     | 199.85     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083857   | 0.083857   | 0.083857   |   0.0 |  0.04
Output  | 0.00036176 | 0.00036176 | 0.00036176 |   0.0 |  0.00
Modify  | 0.53388    | 0.53388    | 0.53388    |   0.0 |  0.27
Other   |            | 0.07801    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5711.00 ave        5711 max        5711 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:      222542.0 ave      222542 max      222542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222542
Ave neighs/atom = 55.635500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.406442433932, Press = -0.112374559644959
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  193000   -13153.514   -13153.514   -13295.347   -13295.347    274.38655    274.38655     67344.73     67344.73   -685.49955   -685.49955 
  194000   -13157.834   -13157.834   -13296.946   -13296.946    269.12181    269.12181    67347.604    67347.604   -873.34563   -873.34563 
Loop time of 138.926 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.622 ns/day, 38.591 hours/ns, 7.198 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    | 138.44     | 138.44     | 138.44     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059551   | 0.059551   | 0.059551   |   0.0 |  0.04
Output  | 0.00010245 | 0.00010245 | 0.00010245 |   0.0 |  0.00
Modify  | 0.3731     | 0.3731     | 0.3731     |   0.0 |  0.27
Other   |            | 0.05614    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      222600.0 ave      222600 max      222600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222600
Ave neighs/atom = 55.650000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.412043676557, Press = -0.00617784894317639
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  194000   -13157.834   -13157.834   -13296.946   -13296.946    269.12181    269.12181    67347.604    67347.604   -873.34563   -873.34563 
  195000   -13153.583   -13153.583   -13295.269   -13295.269    274.10183    274.10183    67306.361    67306.361   -330.62073   -330.62073 
Loop time of 145.066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.596 ns/day, 40.296 hours/ns, 6.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    | 144.56     | 144.56     | 144.56     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061908   | 0.061908   | 0.061908   |   0.0 |  0.04
Output  | 0.00018161 | 0.00018161 | 0.00018161 |   0.0 |  0.00
Modify  | 0.38463    | 0.38463    | 0.38463    |   0.0 |  0.27
Other   |            | 0.05682    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      222494.0 ave      222494 max      222494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222494
Ave neighs/atom = 55.623500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.408339931349, Press = 0.131860924296202
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  195000   -13153.583   -13153.583   -13295.269   -13295.269    274.10183    274.10183    67306.361    67306.361   -330.62073   -330.62073 
  196000   -13157.491   -13157.491   -13297.845   -13297.845    271.52417    271.52417    67221.807    67221.807    391.62913    391.62913 
Loop time of 121.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.713 ns/day, 33.668 hours/ns, 8.250 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    | 120.79     | 120.79     | 120.79     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05111    | 0.05111    | 0.05111    |   0.0 |  0.04
Output  | 0.00010818 | 0.00010818 | 0.00010818 |   0.0 |  0.00
Modify  | 0.32057    | 0.32057    | 0.32057    |   0.0 |  0.26
Other   |            | 0.04664    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5696.00 ave        5696 max        5696 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:      222972.0 ave      222972 max      222972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222972
Ave neighs/atom = 55.743000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.40278928757, Press = 0.0841904730252007
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  196000   -13157.491   -13157.491   -13297.845   -13297.845    271.52417    271.52417    67221.807    67221.807    391.62913    391.62913 
  197000   -13151.986   -13151.986   -13293.949   -13293.949    274.63643    274.63643    67222.982    67222.982    649.32748    649.32748 
Loop time of 119.337 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.724 ns/day, 33.149 hours/ns, 8.380 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    | 118.93     | 118.93     | 118.93     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050056   | 0.050056   | 0.050056   |   0.0 |  0.04
Output  | 9.8779e-05 | 9.8779e-05 | 9.8779e-05 |   0.0 |  0.00
Modify  | 0.31398    | 0.31398    | 0.31398    |   0.0 |  0.26
Other   |            | 0.04511    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5680.00 ave        5680 max        5680 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:      222972.0 ave      222972 max      222972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222972
Ave neighs/atom = 55.743000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.403304911001, Press = 0.00486262494803856
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  197000   -13151.986   -13151.986   -13293.949   -13293.949    274.63643    274.63643    67222.982    67222.982    649.32748    649.32748 
  198000   -13155.566   -13155.566   -13297.424   -13297.424    274.43381    274.43381    67203.312    67203.312    599.51638    599.51638 
Loop time of 124.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.695 ns/day, 34.529 hours/ns, 8.045 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    | 123.88     | 123.88     | 123.88     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052212   | 0.052212   | 0.052212   |   0.0 |  0.04
Output  | 9.6961e-05 | 9.6961e-05 | 9.6961e-05 |   0.0 |  0.00
Modify  | 0.32811    | 0.32811    | 0.32811    |   0.0 |  0.26
Other   |            | 0.04751    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      223490.0 ave      223490 max      223490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223490
Ave neighs/atom = 55.872500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.406261903065, Press = -0.0557870123758321
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  198000   -13155.566   -13155.566   -13297.424   -13297.424    274.43381    274.43381    67203.312    67203.312    599.51638    599.51638 
  199000   -13149.373   -13149.373   -13291.182   -13291.182    274.33978    274.33978    67220.534    67220.534     871.0689     871.0689 
Loop time of 133.611 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.647 ns/day, 37.114 hours/ns, 7.484 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    | 133.15     | 133.15     | 133.15     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056928   | 0.056928   | 0.056928   |   0.0 |  0.04
Output  | 8.6793e-05 | 8.6793e-05 | 8.6793e-05 |   0.0 |  0.00
Modify  | 0.35327    | 0.35327    | 0.35327    |   0.0 |  0.26
Other   |            | 0.05199    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5720.00 ave        5720 max        5720 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:      223262.0 ave      223262 max      223262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223262
Ave neighs/atom = 55.815500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.41331526349, Press = -0.117731370951819
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  199000   -13149.373   -13149.373   -13291.182   -13291.182    274.33978    274.33978    67220.534    67220.534     871.0689     871.0689 
  200000   -13156.685   -13156.685   -13298.338   -13298.338    274.03696    274.03696    67232.154    67232.154    274.23198    274.23198 
Loop time of 190.279 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.454 ns/day, 52.855 hours/ns, 5.255 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    | 189.62     | 189.62     | 189.62     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081752   | 0.081752   | 0.081752   |   0.0 |  0.04
Output  | 0.00018872 | 0.00018872 | 0.00018872 |   0.0 |  0.00
Modify  | 0.50012    | 0.50012    | 0.50012    |   0.0 |  0.26
Other   |            | 0.07216    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5733.00 ave        5733 max        5733 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:      223286.0 ave      223286 max      223286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223286
Ave neighs/atom = 55.821500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.415085078467, Press = -0.245929555022332
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  200000   -13156.685   -13156.685   -13298.338   -13298.338    274.03696    274.03696    67232.154    67232.154    274.23198    274.23198 
  201000   -13151.228   -13151.228   -13294.003   -13294.003    276.20906    276.20906    67319.128    67319.128   -353.35566   -353.35566 
Loop time of 212.858 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.127 hours/ns, 4.698 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    | 212.13     | 212.13     | 212.13     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.089859   | 0.089859   | 0.089859   |   0.0 |  0.04
Output  | 0.00030033 | 0.00030033 | 0.00030033 |   0.0 |  0.00
Modify  | 0.5561     | 0.5561     | 0.5561     |   0.0 |  0.26
Other   |            | 0.07831    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5733.00 ave        5733 max        5733 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:      222852.0 ave      222852 max      222852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222852
Ave neighs/atom = 55.713000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.416385619902, Press = -0.224298855316349
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  201000   -13151.228   -13151.228   -13294.003   -13294.003    276.20906    276.20906    67319.128    67319.128   -353.35566   -353.35566 
  202000   -13154.467   -13154.467   -13294.469   -13294.469    270.84342    270.84342    67329.841    67329.841   -545.54595   -545.54595 
Loop time of 205.484 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.079 hours/ns, 4.867 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    | 204.78     | 204.78     | 204.78     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08767    | 0.08767    | 0.08767    |   0.0 |  0.04
Output  | 0.00020059 | 0.00020059 | 0.00020059 |   0.0 |  0.00
Modify  | 0.54131    | 0.54131    | 0.54131    |   0.0 |  0.26
Other   |            | 0.07843    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5723.00 ave        5723 max        5723 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:      223016.0 ave      223016 max      223016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223016
Ave neighs/atom = 55.754000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.420408899841, Press = -0.105739869483566
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  202000   -13154.467   -13154.467   -13294.469   -13294.469    270.84342    270.84342    67329.841    67329.841   -545.54595   -545.54595 
  203000   -13156.386   -13156.386   -13295.536   -13295.536    269.19533    269.19533    67302.156    67302.156   -296.46129   -296.46129 
Loop time of 180.482 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.479 ns/day, 50.134 hours/ns, 5.541 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    | 179.86     | 179.86     | 179.86     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076691   | 0.076691   | 0.076691   |   0.0 |  0.04
Output  | 0.00034572 | 0.00034572 | 0.00034572 |   0.0 |  0.00
Modify  | 0.47581    | 0.47581    | 0.47581    |   0.0 |  0.26
Other   |            | 0.06969    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5748.00 ave        5748 max        5748 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:      222852.0 ave      222852 max      222852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222852
Ave neighs/atom = 55.713000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.424815069876, Press = -0.0323561908678003
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  203000   -13156.386   -13156.386   -13295.536   -13295.536    269.19533    269.19533    67302.156    67302.156   -296.46129   -296.46129 
  204000   -13154.704   -13154.704    -13295.82    -13295.82    272.99829    272.99829    67302.694    67302.694   -275.31351   -275.31351 
Loop time of 208.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.047 hours/ns, 4.785 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    | 208.26     | 208.26     | 208.26     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.088316   | 0.088316   | 0.088316   |   0.0 |  0.04
Output  | 0.00018408 | 0.00018408 | 0.00018408 |   0.0 |  0.00
Modify  | 0.54671    | 0.54671    | 0.54671    |   0.0 |  0.26
Other   |            | 0.07738    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5721.00 ave        5721 max        5721 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:      222926.0 ave      222926 max      222926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222926
Ave neighs/atom = 55.731500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.428292012735, Press = -0.0511474114124
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  204000   -13154.704   -13154.704    -13295.82    -13295.82    272.99829    272.99829    67302.694    67302.694   -275.31351   -275.31351 
  205000   -13148.847   -13148.847   -13293.094   -13293.094    279.05607    279.05607     67327.93     67327.93   -404.56617   -404.56617 
Loop time of 181.051 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.477 ns/day, 50.292 hours/ns, 5.523 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    | 180.43     | 180.43     | 180.43     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077026   | 0.077026   | 0.077026   |   0.0 |  0.04
Output  | 0.00039647 | 0.00039647 | 0.00039647 |   0.0 |  0.00
Modify  | 0.47471    | 0.47471    | 0.47471    |   0.0 |  0.26
Other   |            | 0.06905    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5727.00 ave        5727 max        5727 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:      222712.0 ave      222712 max      222712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222712
Ave neighs/atom = 55.678000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.428333829704, Press = -0.0194140046016073
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  205000   -13148.847   -13148.847   -13293.094   -13293.094    279.05607    279.05607     67327.93     67327.93   -404.56617   -404.56617 
  206000    -13155.63    -13155.63   -13297.806   -13297.806    275.04909    275.04909    67288.475    67288.475   -227.98229   -227.98229 
Loop time of 207.007 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.502 hours/ns, 4.831 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.29     | 206.29     | 206.29     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086566   | 0.086566   | 0.086566   |   0.0 |  0.04
Output  | 0.00054143 | 0.00054143 | 0.00054143 |   0.0 |  0.00
Modify  | 0.54653    | 0.54653    | 0.54653    |   0.0 |  0.26
Other   |            | 0.07864    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5690.00 ave        5690 max        5690 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:      223036.0 ave      223036 max      223036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223036
Ave neighs/atom = 55.759000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.434030224491, Press = 0.0539843704297828
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  206000    -13155.63    -13155.63   -13297.806   -13297.806    275.04909    275.04909    67288.475    67288.475   -227.98229   -227.98229 
  207000   -13151.764   -13151.764   -13294.679   -13294.679    276.48052    276.48052    67201.333    67201.333    840.30864    840.30864 
Loop time of 225.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.626 hours/ns, 4.436 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    | 224.68     | 224.68     | 224.68     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093507   | 0.093507   | 0.093507   |   0.0 |  0.04
Output  | 0.00019643 | 0.00019643 | 0.00019643 |   0.0 |  0.00
Modify  | 0.59256    | 0.59256    | 0.59256    |   0.0 |  0.26
Other   |            | 0.0824     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5692.00 ave        5692 max        5692 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:      222796.0 ave      222796 max      222796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222796
Ave neighs/atom = 55.699000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.432454586013, Press = 0.119042659980644
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  207000   -13151.764   -13151.764   -13294.679   -13294.679    276.48052    276.48052    67201.333    67201.333    840.30864    840.30864 
  208000   -13154.642   -13154.642   -13295.416   -13295.416    272.33702    272.33702    67166.376    67166.376    1150.7616    1150.7616 
Loop time of 208.728 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.414 ns/day, 57.980 hours/ns, 4.791 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    | 208.01     | 208.01     | 208.01     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087836   | 0.087836   | 0.087836   |   0.0 |  0.04
Output  | 0.0011092  | 0.0011092  | 0.0011092  |   0.0 |  0.00
Modify  | 0.55136    | 0.55136    | 0.55136    |   0.0 |  0.26
Other   |            | 0.07903    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5725.00 ave        5725 max        5725 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:      223240.0 ave      223240 max      223240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223240
Ave neighs/atom = 55.810000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.435107519575, Press = -0.0122223793114346
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  208000   -13154.642   -13154.642   -13295.416   -13295.416    272.33702    272.33702    67166.376    67166.376    1150.7616    1150.7616 
  209000   -13150.649   -13150.649   -13295.265   -13295.265    279.76922    279.76922    67242.445    67242.445    436.17006    436.17006 
Loop time of 217.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.397 ns/day, 60.480 hours/ns, 4.593 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 216.98     | 216.98     | 216.98     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.089794   | 0.089794   | 0.089794   |   0.0 |  0.04
Output  | 0.00024434 | 0.00024434 | 0.00024434 |   0.0 |  0.00
Modify  | 0.57239    | 0.57239    | 0.57239    |   0.0 |  0.26
Other   |            | 0.07946    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5737.00 ave        5737 max        5737 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:      222960.0 ave      222960 max      222960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222960
Ave neighs/atom = 55.740000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.436224768624, Press = -0.109066525854928
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  209000   -13150.649   -13150.649   -13295.265   -13295.265    279.76922    279.76922    67242.445    67242.445    436.17006    436.17006 
  210000   -13155.058   -13155.058   -13296.164   -13296.164     272.9789     272.9789     67258.14     67258.14    179.68779    179.68779 
Loop time of 163.3 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.529 ns/day, 45.361 hours/ns, 6.124 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    | 162.73     | 162.73     | 162.73     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069783   | 0.069783   | 0.069783   |   0.0 |  0.04
Output  | 0.00037982 | 0.00037982 | 0.00037982 |   0.0 |  0.00
Modify  | 0.43761    | 0.43761    | 0.43761    |   0.0 |  0.27
Other   |            | 0.06608    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5708.00 ave        5708 max        5708 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:      223002.0 ave      223002 max      223002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223002
Ave neighs/atom = 55.750500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.438745233505, Press = -0.129742561022113
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  210000   -13155.058   -13155.058   -13296.164   -13296.164     272.9789     272.9789     67258.14     67258.14    179.68779    179.68779 
  211000    -13154.78    -13154.78    -13294.54    -13294.54    270.37514    270.37514    67261.154    67261.154    140.74784    140.74784 
Loop time of 197.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.817 hours/ns, 5.067 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    | 196.66     | 196.66     | 196.66     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083462   | 0.083462   | 0.083462   |   0.0 |  0.04
Output  | 0.00035918 | 0.00035918 | 0.00035918 |   0.0 |  0.00
Modify  | 0.51769    | 0.51769    | 0.51769    |   0.0 |  0.26
Other   |            | 0.07504    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5695.00 ave        5695 max        5695 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:      222778.0 ave      222778 max      222778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222778
Ave neighs/atom = 55.694500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.446247590838, Press = -0.163358181938813
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  211000    -13154.78    -13154.78    -13294.54    -13294.54    270.37514    270.37514    67261.154    67261.154    140.74784    140.74784 
  212000   -13156.082   -13156.082   -13297.286   -13297.286    273.16844    273.16844    67296.871    67296.871   -332.79315   -332.79315 
Loop time of 207.149 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.541 hours/ns, 4.827 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    | 206.44     | 206.44     | 206.44     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.088031   | 0.088031   | 0.088031   |   0.0 |  0.04
Output  | 0.00049095 | 0.00049095 | 0.00049095 |   0.0 |  0.00
Modify  | 0.54293    | 0.54293    | 0.54293    |   0.0 |  0.26
Other   |            | 0.07746    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5686.00 ave        5686 max        5686 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:      223042.0 ave      223042 max      223042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223042
Ave neighs/atom = 55.760500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.44771758071, Press = -0.158876273610125
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  212000   -13156.082   -13156.082   -13297.286   -13297.286    273.16844    273.16844    67296.871    67296.871   -332.79315   -332.79315 
  213000   -13148.725   -13148.725    -13289.81    -13289.81    272.93942    272.93942    67358.788    67358.788   -620.31435   -620.31435 
Loop time of 127.233 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.679 ns/day, 35.342 hours/ns, 7.860 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    | 126.79     | 126.79     | 126.79     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054857   | 0.054857   | 0.054857   |   0.0 |  0.04
Output  | 0.00012994 | 0.00012994 | 0.00012994 |   0.0 |  0.00
Modify  | 0.33795    | 0.33795    | 0.33795    |   0.0 |  0.27
Other   |            | 0.05013    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5719.00 ave        5719 max        5719 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:      222730.0 ave      222730 max      222730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222730
Ave neighs/atom = 55.682500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.452640270971, Press = -0.151780981631078
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  213000   -13148.725   -13148.725    -13289.81    -13289.81    272.93942    272.93942    67358.788    67358.788   -620.31435   -620.31435 
  214000   -13155.296   -13155.296   -13297.418   -13297.418    274.94438    274.94438    67374.831    67374.831   -1224.1824   -1224.1824 
Loop time of 122.42 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.706 ns/day, 34.006 hours/ns, 8.169 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    | 122        | 122        | 122        |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051884   | 0.051884   | 0.051884   |   0.0 |  0.04
Output  | 0.00019206 | 0.00019206 | 0.00019206 |   0.0 |  0.00
Modify  | 0.32241    | 0.32241    | 0.32241    |   0.0 |  0.26
Other   |            | 0.0479     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5688.00 ave        5688 max        5688 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:      223008.0 ave      223008 max      223008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223008
Ave neighs/atom = 55.752000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.455070391039, Press = -0.00853928253261902
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  214000   -13155.296   -13155.296   -13297.418   -13297.418    274.94438    274.94438    67374.831    67374.831   -1224.1824   -1224.1824 
  215000   -13150.003   -13150.003   -13291.648   -13291.648    274.02231    274.02231    67348.875    67348.875   -636.17973   -636.17973 
Loop time of 118.126 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.731 ns/day, 32.813 hours/ns, 8.466 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    | 117.72     | 117.72     | 117.72     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050082   | 0.050082   | 0.050082   |   0.0 |  0.04
Output  | 0.00010229 | 0.00010229 | 0.00010229 |   0.0 |  0.00
Modify  | 0.31111    | 0.31111    | 0.31111    |   0.0 |  0.26
Other   |            | 0.04629    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5724.00 ave        5724 max        5724 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:      222656.0 ave      222656 max      222656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222656
Ave neighs/atom = 55.664000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.459439566113, Press = 0.110886778868138
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  215000   -13150.003   -13150.003   -13291.648   -13291.648    274.02231    274.02231    67348.875    67348.875   -636.17973   -636.17973 
  216000   -13154.831   -13154.831   -13294.095   -13294.095    269.41543    269.41543    67242.983    67242.983    288.25418    288.25418 
Loop time of 121.619 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.710 ns/day, 33.783 hours/ns, 8.222 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    | 121.2      | 121.2      | 121.2      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05155    | 0.05155    | 0.05155    |   0.0 |  0.04
Output  | 0.00010296 | 0.00010296 | 0.00010296 |   0.0 |  0.00
Modify  | 0.31929    | 0.31929    | 0.31929    |   0.0 |  0.26
Other   |            | 0.04644    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5675.00 ave        5675 max        5675 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:      222908.0 ave      222908 max      222908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222908
Ave neighs/atom = 55.727000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.459263311237, Press = 0.0444938424205635
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  216000   -13154.831   -13154.831   -13294.095   -13294.095    269.41543    269.41543    67242.983    67242.983    288.25418    288.25418 
  217000   -13151.807   -13151.807   -13295.146   -13295.146     277.2981     277.2981    67249.822    67249.822    201.10659    201.10659 
Loop time of 114.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.861 hours/ns, 8.718 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    | 114.31     | 114.31     | 114.31     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048095   | 0.048095   | 0.048095   |   0.0 |  0.04
Output  | 0.00010415 | 0.00010415 | 0.00010415 |   0.0 |  0.00
Modify  | 0.29951    | 0.29951    | 0.29951    |   0.0 |  0.26
Other   |            | 0.04301    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5744.00 ave        5744 max        5744 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:      223260.0 ave      223260 max      223260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223260
Ave neighs/atom = 55.815000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.458968258167, Press = -0.0505035040318743
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  217000   -13151.807   -13151.807   -13295.146   -13295.146     277.2981     277.2981    67249.822    67249.822    201.10659    201.10659 
  218000    -13156.55    -13156.55   -13296.355   -13296.355    270.46286    270.46286    67236.407    67236.407    296.94905    296.94905 
Loop time of 125.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.817 hours/ns, 7.978 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    | 124.91     | 124.91     | 124.91     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053246   | 0.053246   | 0.053246   |   0.0 |  0.04
Output  | 0.00010543 | 0.00010543 | 0.00010543 |   0.0 |  0.00
Modify  | 0.32969    | 0.32969    | 0.32969    |   0.0 |  0.26
Other   |            | 0.04804    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5695.00 ave        5695 max        5695 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:      223120.0 ave      223120 max      223120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223120
Ave neighs/atom = 55.780000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454293366051, Press = -0.0936179549335899
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  218000    -13156.55    -13156.55   -13296.355   -13296.355    270.46286    270.46286    67236.407    67236.407    296.94905    296.94905 
  219000   -13154.384   -13154.384   -13296.589   -13296.589    275.10443    275.10443    67244.507    67244.507    269.19291    269.19291 
Loop time of 116.398 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.742 ns/day, 32.333 hours/ns, 8.591 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    | 116        | 116        | 116        |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049081   | 0.049081   | 0.049081   |   0.0 |  0.04
Output  | 0.00010622 | 0.00010622 | 0.00010622 |   0.0 |  0.00
Modify  | 0.30556    | 0.30556    | 0.30556    |   0.0 |  0.26
Other   |            | 0.04434    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      223014.0 ave      223014 max      223014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223014
Ave neighs/atom = 55.753500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454532282517, Press = -0.159957868010724
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  219000   -13154.384   -13154.384   -13296.589   -13296.589    275.10443    275.10443    67244.507    67244.507    269.19291    269.19291 
  220000   -13153.508   -13153.508   -13295.759   -13295.759    275.19481    275.19481    67294.775    67294.775   -243.32438   -243.32438 
Loop time of 117.594 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.735 ns/day, 32.665 hours/ns, 8.504 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    | 117.2      | 117.2      | 117.2      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048895   | 0.048895   | 0.048895   |   0.0 |  0.04
Output  | 0.00010311 | 0.00010311 | 0.00010311 |   0.0 |  0.00
Modify  | 0.30599    | 0.30599    | 0.30599    |   0.0 |  0.26
Other   |            | 0.04421    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5702.00 ave        5702 max        5702 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:      222948.0 ave      222948 max      222948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222948
Ave neighs/atom = 55.737000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.444948557632, Press = -0.270177063619448
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  220000   -13153.508   -13153.508   -13295.759   -13295.759    275.19481    275.19481    67294.775    67294.775   -243.32438   -243.32438 
  221000    -13152.32    -13152.32   -13293.211   -13293.211    272.56333    272.56333    67370.724    67370.724   -912.17353   -912.17353 
Loop time of 122.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.703 ns/day, 34.158 hours/ns, 8.132 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    | 122.55     | 122.55     | 122.55     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051875   | 0.051875   | 0.051875   |   0.0 |  0.04
Output  | 0.00010648 | 0.00010648 | 0.00010648 |   0.0 |  0.00
Modify  | 0.32135    | 0.32135    | 0.32135    |   0.0 |  0.26
Other   |            | 0.04766    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5720.00 ave        5720 max        5720 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:      223024.0 ave      223024 max      223024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223024
Ave neighs/atom = 55.756000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.441400223521, Press = -0.189328601376931
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  221000    -13152.32    -13152.32   -13293.211   -13293.211    272.56333    272.56333    67370.724    67370.724   -912.17353   -912.17353 
  222000    -13154.56    -13154.56   -13293.861   -13293.861     269.4888     269.4888    67357.691    67357.691   -786.56529   -786.56529 
Loop time of 123.086 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.702 ns/day, 34.191 hours/ns, 8.124 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    | 122.66     | 122.66     | 122.66     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051838   | 0.051838   | 0.051838   |   0.0 |  0.04
Output  | 0.00010618 | 0.00010618 | 0.00010618 |   0.0 |  0.00
Modify  | 0.32452    | 0.32452    | 0.32452    |   0.0 |  0.26
Other   |            | 0.04751    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      222734.0 ave      222734 max      222734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222734
Ave neighs/atom = 55.683500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.440132596008, Press = -0.0417288826927978
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  222000    -13154.56    -13154.56   -13293.861   -13293.861     269.4888     269.4888    67357.691    67357.691   -786.56529   -786.56529 
  223000   -13154.607   -13154.607   -13296.341   -13296.341      274.195      274.195     67315.29     67315.29   -499.99684   -499.99684 
Loop time of 136.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.634 ns/day, 37.848 hours/ns, 7.339 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    | 135.78     | 135.78     | 135.78     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058559   | 0.058559   | 0.058559   |   0.0 |  0.04
Output  | 0.00010366 | 0.00010366 | 0.00010366 |   0.0 |  0.00
Modify  | 0.35944    | 0.35944    | 0.35944    |   0.0 |  0.26
Other   |            | 0.0535     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      222600.0 ave      222600 max      222600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222600
Ave neighs/atom = 55.650000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.440006756449, Press = 0.0188899853193996
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  223000   -13154.607   -13154.607   -13296.341   -13296.341      274.195      274.195     67315.29     67315.29   -499.99684   -499.99684 
  224000   -13153.772   -13153.772   -13295.839   -13295.839    274.83756    274.83756    67276.666    67276.666    11.964886    11.964886 
Loop time of 123.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.700 ns/day, 34.296 hours/ns, 8.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    | 123.04     | 123.04     | 123.04     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052074   | 0.052074   | 0.052074   |   0.0 |  0.04
Output  | 0.00010603 | 0.00010603 | 0.00010603 |   0.0 |  0.00
Modify  | 0.3233     | 0.3233     | 0.3233     |   0.0 |  0.26
Other   |            | 0.04724    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5718.00 ave        5718 max        5718 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:      222852.0 ave      222852 max      222852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222852
Ave neighs/atom = 55.713000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.437375216015, Press = -0.0364300948187297
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  224000   -13153.772   -13153.772   -13295.839   -13295.839    274.83756    274.83756    67276.666    67276.666    11.964886    11.964886 
  225000   -13156.851   -13156.851   -13295.872   -13295.872    268.94602    268.94602    67275.021    67275.021   -123.54275   -123.54275 
Loop time of 140.75 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.614 ns/day, 39.097 hours/ns, 7.105 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    | 140.26     | 140.26     | 140.26     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060742   | 0.060742   | 0.060742   |   0.0 |  0.04
Output  | 0.00017009 | 0.00017009 | 0.00017009 |   0.0 |  0.00
Modify  | 0.37538    | 0.37538    | 0.37538    |   0.0 |  0.27
Other   |            | 0.05683    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5725.00 ave        5725 max        5725 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:      222932.0 ave      222932 max      222932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222932
Ave neighs/atom = 55.733000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.436669827053, Press = -0.0584583605321708
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  225000   -13156.851   -13156.851   -13295.872   -13295.872    268.94602    268.94602    67275.021    67275.021   -123.54275   -123.54275 
  226000   -13158.144   -13158.144   -13298.059   -13298.059    270.67432    270.67432    67259.927    67259.927   -30.349106   -30.349106 
Loop time of 175.685 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.492 ns/day, 48.801 hours/ns, 5.692 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    | 175.07     | 175.07     | 175.07     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076035   | 0.076035   | 0.076035   |   0.0 |  0.04
Output  | 0.00050148 | 0.00050148 | 0.00050148 |   0.0 |  0.00
Modify  | 0.47105    | 0.47105    | 0.47105    |   0.0 |  0.27
Other   |            | 0.07091    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5725.00 ave        5725 max        5725 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:      223008.0 ave      223008 max      223008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223008
Ave neighs/atom = 55.752000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.436631286022, Press = -0.103506352121468
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  226000   -13158.144   -13158.144   -13298.059   -13298.059    270.67432    270.67432    67259.927    67259.927   -30.349106   -30.349106 
  227000    -13152.49    -13152.49   -13292.782   -13292.782    271.40481    271.40481     67320.34     67320.34   -368.99811   -368.99811 
Loop time of 158.822 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.544 ns/day, 44.117 hours/ns, 6.296 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    | 158.26     | 158.26     | 158.26     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068433   | 0.068433   | 0.068433   |   0.0 |  0.04
Output  | 0.00039207 | 0.00039207 | 0.00039207 |   0.0 |  0.00
Modify  | 0.42512    | 0.42512    | 0.42512    |   0.0 |  0.27
Other   |            | 0.06571    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5689.00 ave        5689 max        5689 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:      223056.0 ave      223056 max      223056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223056
Ave neighs/atom = 55.764000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.430228867117, Press = -0.171105990244117
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  227000    -13152.49    -13152.49   -13292.782   -13292.782    271.40481    271.40481     67320.34     67320.34   -368.99811   -368.99811 
  228000   -13155.851   -13155.851   -13300.268   -13300.268    279.38459    279.38459    67379.465    67379.465   -1305.6752   -1305.6752 
Loop time of 199.584 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.440 hours/ns, 5.010 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    | 198.89     | 198.89     | 198.89     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084782   | 0.084782   | 0.084782   |   0.0 |  0.04
Output  | 0.00021659 | 0.00021659 | 0.00021659 |   0.0 |  0.00
Modify  | 0.52835    | 0.52835    | 0.52835    |   0.0 |  0.26
Other   |            | 0.07696    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5655.00 ave        5655 max        5655 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:      222758.0 ave      222758 max      222758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222758
Ave neighs/atom = 55.689500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.422565480072, Press = -0.13796336000281
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  228000   -13155.851   -13155.851   -13300.268   -13300.268    279.38459    279.38459    67379.465    67379.465   -1305.6752   -1305.6752 
  229000    -13154.17    -13154.17    -13294.31    -13294.31    271.10949    271.10949    67371.729    67371.729    -962.2636    -962.2636 
Loop time of 203.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.546 hours/ns, 4.912 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    | 202.87     | 202.87     | 202.87     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085287   | 0.085287   | 0.085287   |   0.0 |  0.04
Output  | 0.00012186 | 0.00012186 | 0.00012186 |   0.0 |  0.00
Modify  | 0.53461    | 0.53461    | 0.53461    |   0.0 |  0.26
Other   |            | 0.07558    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5715.00 ave        5715 max        5715 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:      222324.0 ave      222324 max      222324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222324
Ave neighs/atom = 55.581000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.413529496955, Press = -0.00851987364467906
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  229000    -13154.17    -13154.17    -13294.31    -13294.31    271.10949    271.10949    67371.729    67371.729    -962.2636    -962.2636 
  230000    -13154.07    -13154.07   -13295.367   -13295.367     273.3475     273.3475    67294.432    67294.432   -159.38493   -159.38493 
Loop time of 203.666 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.574 hours/ns, 4.910 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    | 202.97     | 202.97     | 202.97     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085429   | 0.085429   | 0.085429   |   0.0 |  0.04
Output  | 0.00016919 | 0.00016919 | 0.00016919 |   0.0 |  0.00
Modify  | 0.53423    | 0.53423    | 0.53423    |   0.0 |  0.26
Other   |            | 0.07679    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5703.00 ave        5703 max        5703 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:      222482.0 ave      222482 max      222482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222482
Ave neighs/atom = 55.620500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.408837685392, Press = 0.0599002816007701
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  230000    -13154.07    -13154.07   -13295.367   -13295.367     273.3475     273.3475    67294.432    67294.432   -159.38493   -159.38493 
  231000   -13155.139   -13155.139    -13295.74    -13295.74     272.0033     272.0033     67243.96     67243.96    346.55815    346.55815 
Loop time of 195.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.184 hours/ns, 5.127 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    | 194.39     | 194.39     | 194.39     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083063   | 0.083063   | 0.083063   |   0.0 |  0.04
Output  | 9.0399e-05 | 9.0399e-05 | 9.0399e-05 |   0.0 |  0.00
Modify  | 0.51458    | 0.51458    | 0.51458    |   0.0 |  0.26
Other   |            | 0.07601    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      222706.0 ave      222706 max      222706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222706
Ave neighs/atom = 55.676500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.406602720209, Press = -0.0107743377888917
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  231000   -13155.139   -13155.139    -13295.74    -13295.74     272.0033     272.0033     67243.96     67243.96    346.55815    346.55815 
  232000   -13155.018   -13155.018   -13298.024   -13298.024    276.65444    276.65444    67260.347    67260.347    39.054453    39.054453 
Loop time of 209.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.288 hours/ns, 4.766 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    | 209.12     | 209.12     | 209.12     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0886     | 0.0886     | 0.0886     |   0.0 |  0.04
Output  | 0.00019503 | 0.00019503 | 0.00019503 |   0.0 |  0.00
Modify  | 0.54755    | 0.54755    | 0.54755    |   0.0 |  0.26
Other   |            | 0.07733    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5759.00 ave        5759 max        5759 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:      223166.0 ave      223166 max      223166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223166
Ave neighs/atom = 55.791500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.407357467255, Press = -0.0742832418940781
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  232000   -13155.018   -13155.018   -13298.024   -13298.024    276.65444    276.65444    67260.347    67260.347    39.054453    39.054453 
  233000   -13154.123   -13154.123   -13294.198   -13294.198     270.9849     270.9849    67283.018    67283.018   -154.43557   -154.43557 
Loop time of 212.802 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.112 hours/ns, 4.699 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    | 212.07     | 212.07     | 212.07     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.089773   | 0.089773   | 0.089773   |   0.0 |  0.04
Output  | 0.00018425 | 0.00018425 | 0.00018425 |   0.0 |  0.00
Modify  | 0.55895    | 0.55895    | 0.55895    |   0.0 |  0.26
Other   |            | 0.07919    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5705.00 ave        5705 max        5705 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:      222910.0 ave      222910 max      222910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222910
Ave neighs/atom = 55.727500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.40576044483, Press = -0.100903310250148
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  233000   -13154.123   -13154.123   -13294.198   -13294.198     270.9849     270.9849    67283.018    67283.018   -154.43557   -154.43557 
  234000   -13159.806   -13159.806   -13299.445   -13299.445    270.14198    270.14198    67264.278    67264.278   -124.15204   -124.15204 
Loop time of 168.745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.512 ns/day, 46.873 hours/ns, 5.926 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    | 168.15     | 168.15     | 168.15     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074274   | 0.074274   | 0.074274   |   0.0 |  0.04
Output  | 0.00010729 | 0.00010729 | 0.00010729 |   0.0 |  0.00
Modify  | 0.45247    | 0.45247    | 0.45247    |   0.0 |  0.27
Other   |            | 0.06929    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5722.00 ave        5722 max        5722 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:      223194.0 ave      223194 max      223194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223194
Ave neighs/atom = 55.798500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.401362300482, Press = -0.0845918363420925
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  234000   -13159.806   -13159.806   -13299.445   -13299.445    270.14198    270.14198    67264.278    67264.278   -124.15204   -124.15204 
  235000   -13154.581   -13154.581   -13296.039   -13296.039    273.66009    273.66009    67247.827    67247.827    232.26275    232.26275 
Loop time of 121.253 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.713 ns/day, 33.681 hours/ns, 8.247 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    | 120.83     | 120.83     | 120.83     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051876   | 0.051876   | 0.051876   |   0.0 |  0.04
Output  | 0.00018486 | 0.00018486 | 0.00018486 |   0.0 |  0.00
Modify  | 0.31934    | 0.31934    | 0.31934    |   0.0 |  0.26
Other   |            | 0.04638    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5751.00 ave        5751 max        5751 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:      222758.0 ave      222758 max      222758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222758
Ave neighs/atom = 55.689500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.391569790223, Press = -0.0686198856785309
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  235000   -13154.581   -13154.581   -13296.039   -13296.039    273.66009    273.66009    67247.827    67247.827    232.26275    232.26275 
  236000    -13157.78    -13157.78   -13297.204   -13297.204    269.72642    269.72642     67222.75     67222.75    393.82894    393.82894 
Loop time of 114.15 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.708 hours/ns, 8.760 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    | 113.76     | 113.76     | 113.76     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047877   | 0.047877   | 0.047877   |   0.0 |  0.04
Output  | 0.00010775 | 0.00010775 | 0.00010775 |   0.0 |  0.00
Modify  | 0.29808    | 0.29808    | 0.29808    |   0.0 |  0.26
Other   |            | 0.04248    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5728.00 ave        5728 max        5728 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:      222980.0 ave      222980 max      222980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222980
Ave neighs/atom = 55.745000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.386727447293, Press = -0.139983058776409
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  236000    -13157.78    -13157.78   -13297.204   -13297.204    269.72642    269.72642     67222.75     67222.75    393.82894    393.82894 
  237000   -13151.395   -13151.395   -13293.647   -13293.647    275.19657    275.19657    67280.837    67280.837    36.935243    36.935243 
Loop time of 132.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.651 ns/day, 36.847 hours/ns, 7.539 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    | 132.19     | 132.19     | 132.19     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057245   | 0.057245   | 0.057245   |   0.0 |  0.04
Output  | 0.00039092 | 0.00039092 | 0.00039092 |   0.0 |  0.00
Modify  | 0.35192    | 0.35192    | 0.35192    |   0.0 |  0.27
Other   |            | 0.05231    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      223030.0 ave      223030 max      223030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223030
Ave neighs/atom = 55.757500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.377581300227, Press = -0.196918882350941
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  237000   -13151.395   -13151.395   -13293.647   -13293.647    275.19657    275.19657    67280.837    67280.837    36.935243    36.935243 
  238000   -13153.849   -13153.849   -13294.319   -13294.319    271.74949    271.74949    67350.548    67350.548   -774.03656   -774.03656 
Loop time of 208.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.414 ns/day, 57.952 hours/ns, 4.793 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    | 207.91     | 207.91     | 207.91     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.088841   | 0.088841   | 0.088841   |   0.0 |  0.04
Output  | 0.00029708 | 0.00029708 | 0.00029708 |   0.0 |  0.00
Modify  | 0.55172    | 0.55172    | 0.55172    |   0.0 |  0.26
Other   |            | 0.07989    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5717.00 ave        5717 max        5717 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:      223026.0 ave      223026 max      223026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223026
Ave neighs/atom = 55.756500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.37843428699, Press = -0.208262515490112
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  238000   -13153.849   -13153.849   -13294.319   -13294.319    271.74949    271.74949    67350.548    67350.548   -774.03656   -774.03656 
  239000   -13154.594   -13154.594   -13294.665   -13294.665    270.97737    270.97737    67353.319    67353.319   -857.20738   -857.20738 
Loop time of 196.231 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.509 hours/ns, 5.096 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    | 195.55     | 195.55     | 195.55     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08403    | 0.08403    | 0.08403    |   0.0 |  0.04
Output  | 0.0003671  | 0.0003671  | 0.0003671  |   0.0 |  0.00
Modify  | 0.51816    | 0.51816    | 0.51816    |   0.0 |  0.26
Other   |            | 0.07455    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5687.00 ave        5687 max        5687 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:      222892.0 ave      222892 max      222892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222892
Ave neighs/atom = 55.723000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.377171128311, Press = -0.0918101788001534
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  239000   -13154.594   -13154.594   -13294.665   -13294.665    270.97737    270.97737    67353.319    67353.319   -857.20738   -857.20738 
  240000   -13151.781   -13151.781   -13292.723   -13292.723    272.66283    272.66283    67313.094    67313.094   -296.26206   -296.26206 
Loop time of 225.823 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.729 hours/ns, 4.428 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    | 225.06     | 225.06     | 225.06     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094044   | 0.094044   | 0.094044   |   0.0 |  0.04
Output  | 0.0001841  | 0.0001841  | 0.0001841  |   0.0 |  0.00
Modify  | 0.58498    | 0.58498    | 0.58498    |   0.0 |  0.26
Other   |            | 0.07995    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5710.00 ave        5710 max        5710 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:      222912.0 ave      222912 max      222912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222912
Ave neighs/atom = 55.728000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.377436373441, Press = -0.0495536384087584
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  240000   -13151.781   -13151.781   -13292.723   -13292.723    272.66283    272.66283    67313.094    67313.094   -296.26206   -296.26206 
  241000   -13152.987   -13152.987   -13293.287   -13293.287    271.41927    271.41927    67290.669    67290.669   -51.152047   -51.152047 
Loop time of 197.432 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.842 hours/ns, 5.065 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    | 196.76     | 196.76     | 196.76     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083473   | 0.083473   | 0.083473   |   0.0 |  0.04
Output  | 0.00036011 | 0.00036011 | 0.00036011 |   0.0 |  0.00
Modify  | 0.51665    | 0.51665    | 0.51665    |   0.0 |  0.26
Other   |            | 0.0735     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5711.00 ave        5711 max        5711 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:      223042.0 ave      223042 max      223042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223042
Ave neighs/atom = 55.760500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.373719019611, Press = -0.0219230269027094
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  241000   -13152.987   -13152.987   -13293.287   -13293.287    271.41927    271.41927    67290.669    67290.669   -51.152047   -51.152047 
  242000   -13157.569   -13157.569   -13297.555   -13297.555    270.81185    270.81185    67232.887    67232.887    233.27564    233.27564 
Loop time of 195.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.184 hours/ns, 5.127 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    | 194.38     | 194.38     | 194.38     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083199   | 0.083199   | 0.083199   |   0.0 |  0.04
Output  | 0.00017899 | 0.00017899 | 0.00017899 |   0.0 |  0.00
Modify  | 0.52351    | 0.52351    | 0.52351    |   0.0 |  0.27
Other   |            | 0.07813    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5721.00 ave        5721 max        5721 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:      223082.0 ave      223082 max      223082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223082
Ave neighs/atom = 55.770500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.375196570563, Press = -0.015245805157432
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  242000   -13157.569   -13157.569   -13297.555   -13297.555    270.81185    270.81185    67232.887    67232.887    233.27564    233.27564 
  243000   -13153.477   -13153.477   -13294.582   -13294.582    272.97767    272.97767    67152.116    67152.116    1303.7122    1303.7122 
Loop time of 197.659 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.905 hours/ns, 5.059 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    | 196.97     | 196.97     | 196.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083863   | 0.083863   | 0.083863   |   0.0 |  0.04
Output  | 0.00011498 | 0.00011498 | 0.00011498 |   0.0 |  0.00
Modify  | 0.5266     | 0.5266     | 0.5266     |   0.0 |  0.27
Other   |            | 0.07556    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5709.00 ave        5709 max        5709 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:      223042.0 ave      223042 max      223042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223042
Ave neighs/atom = 55.760500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.37788805908, Press = 0.0224896356807093
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  243000   -13153.477   -13153.477   -13294.582   -13294.582    272.97767    272.97767    67152.116    67152.116    1303.7122    1303.7122 
  244000   -13155.367   -13155.367   -13295.981   -13295.981    272.02813    272.02813    67113.331    67113.331    1628.4604    1628.4604 
Loop time of 210.908 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.585 hours/ns, 4.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 210.19     | 210.19     | 210.19     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087205   | 0.087205   | 0.087205   |   0.0 |  0.04
Output  | 0.00018145 | 0.00018145 | 0.00018145 |   0.0 |  0.00
Modify  | 0.55613    | 0.55613    | 0.55613    |   0.0 |  0.26
Other   |            | 0.07777    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5716.00 ave        5716 max        5716 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:      223438.0 ave      223438 max      223438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223438
Ave neighs/atom = 55.859500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.380407418147, Press = -0.110665182326159
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  244000   -13155.367   -13155.367   -13295.981   -13295.981    272.02813    272.02813    67113.331    67113.331    1628.4604    1628.4604 
  245000   -13153.986   -13153.986   -13297.278   -13297.278     277.2094     277.2094    67222.741    67222.741    444.43443    444.43443 
Loop time of 211.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.656 hours/ns, 4.736 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 210.43     | 210.43     | 210.43     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.088606   | 0.088606   | 0.088606   |   0.0 |  0.04
Output  | 0.0003172  | 0.0003172  | 0.0003172  |   0.0 |  0.00
Modify  | 0.56302    | 0.56302    | 0.56302    |   0.0 |  0.27
Other   |            | 0.07989    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5700.00 ave        5700 max        5700 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:      223404.0 ave      223404 max      223404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223404
Ave neighs/atom = 55.851000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.379981272029, Press = -0.161100201753562
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  245000   -13153.986   -13153.986   -13297.278   -13297.278     277.2094     277.2094    67222.741    67222.741    444.43443    444.43443 
  246000   -13155.246   -13155.246   -13296.188   -13296.188    272.66178    272.66178    67256.225    67256.225    91.273422    91.273422 
Loop time of 163.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.527 ns/day, 45.538 hours/ns, 6.100 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    | 163.36     | 163.36     | 163.36     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070854   | 0.070854   | 0.070854   |   0.0 |  0.04
Output  | 0.00036725 | 0.00036725 | 0.00036725 |   0.0 |  0.00
Modify  | 0.43698    | 0.43698    | 0.43698    |   0.0 |  0.27
Other   |            | 0.06608    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5739.00 ave        5739 max        5739 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:      223130.0 ave      223130 max      223130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223130
Ave neighs/atom = 55.782500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.374245009425, Press = -0.139824633553722
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  246000   -13155.246   -13155.246   -13296.188   -13296.188    272.66178    272.66178    67256.225    67256.225    91.273422    91.273422 
  247000   -13154.059   -13154.059   -13294.046   -13294.046    270.81516    270.81516     67286.48     67286.48    -167.8158    -167.8158 
Loop time of 122.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.704 ns/day, 34.083 hours/ns, 8.150 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    | 122.27     | 122.27     | 122.27     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052968   | 0.052968   | 0.052968   |   0.0 |  0.04
Output  | 0.00013078 | 0.00013078 | 0.00013078 |   0.0 |  0.00
Modify  | 0.32876    | 0.32876    | 0.32876    |   0.0 |  0.27
Other   |            | 0.04964    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5735.00 ave        5735 max        5735 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:      223064.0 ave      223064 max      223064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223064
Ave neighs/atom = 55.766000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.369318055912, Press = -0.158650619623417
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  247000   -13154.059   -13154.059   -13294.046   -13294.046    270.81516    270.81516     67286.48     67286.48    -167.8158    -167.8158 
  248000    -13154.32    -13154.32   -13296.396   -13296.396    274.85529    274.85529    67383.793    67383.793   -1237.5693   -1237.5693 
Loop time of 125.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.812 hours/ns, 7.979 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    | 124.89     | 124.89     | 124.89     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052959   | 0.052959   | 0.052959   |   0.0 |  0.04
Output  | 0.00018413 | 0.00018413 | 0.00018413 |   0.0 |  0.00
Modify  | 0.32848    | 0.32848    | 0.32848    |   0.0 |  0.26
Other   |            | 0.04884    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      223144.0 ave      223144 max      223144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223144
Ave neighs/atom = 55.786000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.360705169944, Press = -0.194048399535906
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  248000    -13154.32    -13154.32   -13296.396   -13296.396    274.85529    274.85529    67383.793    67383.793   -1237.5693   -1237.5693 
  249000   -13154.777   -13154.777   -13294.125   -13294.125    269.57788    269.57788    67433.475    67433.475   -1679.6884   -1679.6884 
Loop time of 125.465 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.851 hours/ns, 7.970 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    | 125.03     | 125.03     | 125.03     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053947   | 0.053947   | 0.053947   |   0.0 |  0.04
Output  | 0.00035539 | 0.00035539 | 0.00035539 |   0.0 |  0.00
Modify  | 0.33407    | 0.33407    | 0.33407    |   0.0 |  0.27
Other   |            | 0.05142    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5719.00 ave        5719 max        5719 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:      222656.0 ave      222656 max      222656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222656
Ave neighs/atom = 55.664000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.358205936995, Press = -0.0366340431906097
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  249000   -13154.777   -13154.777   -13294.125   -13294.125    269.57788    269.57788    67433.475    67433.475   -1679.6884   -1679.6884 
  250000   -13153.211   -13153.211   -13292.549   -13292.549    269.55949    269.55949    67317.484    67317.484   -318.96397   -318.96397 
Loop time of 121.087 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.714 ns/day, 33.635 hours/ns, 8.259 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    | 120.67     | 120.67     | 120.67     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051565   | 0.051565   | 0.051565   |   0.0 |  0.04
Output  | 0.00011179 | 0.00011179 | 0.00011179 |   0.0 |  0.00
Modify  | 0.32086    | 0.32086    | 0.32086    |   0.0 |  0.26
Other   |            | 0.04725    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5704.00 ave        5704 max        5704 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:      222564.0 ave      222564 max      222564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222564
Ave neighs/atom = 55.641000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.358025251731, Press = 0.0429090392472953
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  250000   -13153.211   -13153.211   -13292.549   -13292.549    269.55949    269.55949    67317.484    67317.484   -318.96397   -318.96397 
  251000   -13160.464   -13160.464    -13300.43    -13300.43    270.77375    270.77375    67215.425    67215.425    345.67697    345.67697 
Loop time of 122.764 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.704 ns/day, 34.101 hours/ns, 8.146 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    | 122.34     | 122.34     | 122.34     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051489   | 0.051489   | 0.051489   |   0.0 |  0.04
Output  | 0.00017134 | 0.00017134 | 0.00017134 |   0.0 |  0.00
Modify  | 0.32331    | 0.32331    | 0.32331    |   0.0 |  0.26
Other   |            | 0.04682    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5702.00 ave        5702 max        5702 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:      223042.0 ave      223042 max      223042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223042
Ave neighs/atom = 55.760500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.355309432632, Press = 0.0556572435146876
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  251000   -13160.464   -13160.464    -13300.43    -13300.43    270.77375    270.77375    67215.425    67215.425    345.67697    345.67697 
  252000   -13153.597   -13153.597    -13292.34    -13292.34    268.40718    268.40718    67200.084    67200.084    886.57543    886.57543 
Loop time of 129.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.667 ns/day, 35.974 hours/ns, 7.722 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    | 129.06     | 129.06     | 129.06     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055972   | 0.055972   | 0.055972   |   0.0 |  0.04
Output  | 0.00010531 | 0.00010531 | 0.00010531 |   0.0 |  0.00
Modify  | 0.34383    | 0.34383    | 0.34383    |   0.0 |  0.27
Other   |            | 0.05095    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5739.00 ave        5739 max        5739 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:      222752.0 ave      222752 max      222752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 222752
Ave neighs/atom = 55.688000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
67273.5878486081

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0