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

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

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

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

kim_interactions Mo

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

kim interactions Mo
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongParkDo_2018_PdMo__MO_356501945107_001
pair_coeff * * Mo
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 95.94

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31153.5559995522 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_356501945107_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -13549.42    -13549.42       -13620       -13620       273.15       273.15    31153.556    31153.556    2419.8511    2419.8511 
    1000    -13477.19    -13477.19   -13555.159   -13555.159    301.74636    301.74636    31261.825    31261.825    2457.9557    2457.9557 
Loop time of 113.806 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.3      | 113.3      | 113.3      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10023    | 0.10023    | 0.10023    |   0.0 |  0.09
Output  | 0.00023064 | 0.00023064 | 0.00023064 |   0.0 |  0.00
Modify  | 0.34356    | 0.34356    | 0.34356    |   0.0 |  0.30
Other   |            | 0.05813    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -13477.19    -13477.19   -13555.159   -13555.159    301.74636    301.74636    31261.825    31261.825    2457.9557    2457.9557 
    2000   -13475.798   -13475.798   -13547.037   -13547.037    275.70329    275.70329    31271.943    31271.943    2975.2505    2975.2505 
Loop time of 114.154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.709 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.67     | 113.67     | 113.67     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096531   | 0.096531   | 0.096531   |   0.0 |  0.08
Output  | 0.00022918 | 0.00022918 | 0.00022918 |   0.0 |  0.00
Modify  | 0.33307    | 0.33307    | 0.33307    |   0.0 |  0.29
Other   |            | 0.0588     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13475.798   -13475.798   -13547.037   -13547.037    275.70329    275.70329    31271.943    31271.943    2975.2505    2975.2505 
    3000   -13478.957   -13478.957   -13547.341   -13547.341    264.65222    264.65222    31278.949    31278.949    1881.6007    1881.6007 
Loop time of 113.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.619 hours/ns, 8.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    | 113.34     | 113.34     | 113.34     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095446   | 0.095446   | 0.095446   |   0.0 |  0.08
Output  | 0.00019212 | 0.00019212 | 0.00019212 |   0.0 |  0.00
Modify  | 0.3335     | 0.3335     | 0.3335     |   0.0 |  0.29
Other   |            | 0.05914    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13478.957   -13478.957   -13547.341   -13547.341    264.65222    264.65222    31278.949    31278.949    1881.6007    1881.6007 
    4000   -13475.231   -13475.231   -13545.016   -13545.016    270.07625    270.07625    31291.288    31291.288    1163.3194    1163.3194 
Loop time of 113.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.663 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.5      | 113.5      | 113.5      |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096298   | 0.096298   | 0.096298   |   0.0 |  0.08
Output  | 0.00023353 | 0.00023353 | 0.00023353 |   0.0 |  0.00
Modify  | 0.33473    | 0.33473    | 0.33473    |   0.0 |  0.29
Other   |            | 0.05857    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13475.231   -13475.231   -13545.016   -13545.016    270.07625    270.07625    31291.288    31291.288    1163.3194    1163.3194 
    5000   -13479.371   -13479.371   -13546.566   -13546.566    260.05428    260.05428    31287.275    31287.275     953.3978     953.3978 
Loop time of 113.552 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.542 hours/ns, 8.807 timesteps/s
100.0% 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.06     | 113.06     | 113.06     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096514   | 0.096514   | 0.096514   |   0.0 |  0.08
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.33521    | 0.33521    | 0.33521    |   0.0 |  0.30
Other   |            | 0.05868    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.445955109754, Press = -18.3822227806948
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13479.371   -13479.371   -13546.566   -13546.566    260.05428    260.05428    31287.275    31287.275     953.3978     953.3978 
    6000     -13475.5     -13475.5   -13549.993   -13549.993    288.29517    288.29517    31283.443    31283.443    1266.9396    1266.9396 
Loop time of 114.11 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.6      | 113.6      | 113.6      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097282   | 0.097282   | 0.097282   |   0.0 |  0.09
Output  | 0.00015601 | 0.00015601 | 0.00015601 |   0.0 |  0.00
Modify  | 0.3517     | 0.3517     | 0.3517     |   0.0 |  0.31
Other   |            | 0.05828    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.641696436865, Press = 18.4354228682279
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000     -13475.5     -13475.5   -13549.993   -13549.993    288.29517    288.29517    31283.443    31283.443    1266.9396    1266.9396 
    7000   -13477.173   -13477.173   -13546.591   -13546.591    268.65235    268.65235    31293.197    31293.197    751.96948    751.96948 
Loop time of 113.981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.661 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.47     | 113.47     | 113.47     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096241   | 0.096241   | 0.096241   |   0.0 |  0.08
Output  | 0.0001554  | 0.0001554  | 0.0001554  |   0.0 |  0.00
Modify  | 0.3509     | 0.3509     | 0.3509     |   0.0 |  0.31
Other   |            | 0.05895    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.731179503017, Press = 13.1485303425917
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13477.173   -13477.173   -13546.591   -13546.591    268.65235    268.65235    31293.197    31293.197    751.96948    751.96948 
    8000   -13478.967   -13478.967   -13548.386   -13548.386    268.65924    268.65924    31299.855    31299.855    15.118985    15.118985 
Loop time of 114.19 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.719 hours/ns, 8.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    | 113.68     | 113.68     | 113.68     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095989   | 0.095989   | 0.095989   |   0.0 |  0.08
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.35162    | 0.35162    | 0.35162    |   0.0 |  0.31
Other   |            | 0.0589     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.476575346094, Press = -1.37981795908178
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13478.967   -13478.967   -13548.386   -13548.386    268.65924    268.65924    31299.855    31299.855    15.118985    15.118985 
    9000   -13476.952   -13476.952   -13547.141   -13547.141    271.63821    271.63821    31308.086    31308.086   -370.17194   -370.17194 
Loop time of 113.959 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.655 hours/ns, 8.775 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.45     | 113.45     | 113.45     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095924   | 0.095924   | 0.095924   |   0.0 |  0.08
Output  | 0.00015689 | 0.00015689 | 0.00015689 |   0.0 |  0.00
Modify  | 0.35224    | 0.35224    | 0.35224    |   0.0 |  0.31
Other   |            | 0.05878    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.328483715644, Press = -2.69271454214933
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13476.952   -13476.952   -13547.141   -13547.141    271.63821    271.63821    31308.086    31308.086   -370.17194   -370.17194 
   10000   -13481.877   -13481.877   -13549.931   -13549.931    263.37523    263.37523    31301.586    31301.586    -275.0226    -275.0226 
Loop time of 113.696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.582 hours/ns, 8.795 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.19     | 113.19     | 113.19     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096258   | 0.096258   | 0.096258   |   0.0 |  0.08
Output  | 0.00019854 | 0.00019854 | 0.00019854 |   0.0 |  0.00
Modify  | 0.35043    | 0.35043    | 0.35043    |   0.0 |  0.31
Other   |            | 0.05884    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.177103386808, Press = -4.38544186151462
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13481.877   -13481.877   -13549.931   -13549.931    263.37523    263.37523    31301.586    31301.586    -275.0226    -275.0226 
   11000   -13477.232   -13477.232   -13548.744   -13548.744    276.75716    276.75716    31307.473    31307.473   -618.37362   -618.37362 
Loop time of 114.11 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.697 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.6      | 113.6      | 113.6      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096785   | 0.096785   | 0.096785   |   0.0 |  0.08
Output  | 0.00015593 | 0.00015593 | 0.00015593 |   0.0 |  0.00
Modify  | 0.35108    | 0.35108    | 0.35108    |   0.0 |  0.31
Other   |            | 0.05885    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.022603878733, Press = -2.46427862706734
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13477.232   -13477.232   -13548.744   -13548.744    276.75716    276.75716    31307.473    31307.473   -618.37362   -618.37362 
   12000    -13477.33    -13477.33   -13547.551   -13547.551    271.76204    271.76204    31317.401    31317.401    -1226.752    -1226.752 
Loop time of 113.892 on 1 procs for 1000 steps with 2000 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.39     | 113.39     | 113.39     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096765   | 0.096765   | 0.096765   |   0.0 |  0.08
Output  | 0.00015649 | 0.00015649 | 0.00015649 |   0.0 |  0.00
Modify  | 0.35172    | 0.35172    | 0.35172    |   0.0 |  0.31
Other   |            | 0.0587     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.310572854417, Press = -1.64646198465675
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -13477.33    -13477.33   -13547.551   -13547.551    271.76204    271.76204    31317.401    31317.401    -1226.752    -1226.752 
   13000   -13477.029   -13477.029   -13548.021   -13548.021    274.74977    274.74977    31340.137    31340.137   -3326.7848   -3326.7848 
Loop time of 131.329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.480 hours/ns, 7.614 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.73     | 130.73     | 130.73     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10764    | 0.10764    | 0.10764    |   0.0 |  0.08
Output  | 0.00019059 | 0.00019059 | 0.00019059 |   0.0 |  0.00
Modify  | 0.4283     | 0.4283     | 0.4283     |   0.0 |  0.33
Other   |            | 0.0654     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.365041777003, Press = -2.5026459205722
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13477.029   -13477.029   -13548.021   -13548.021    274.74977    274.74977    31340.137    31340.137   -3326.7848   -3326.7848 
   14000   -13479.498   -13479.498   -13548.388   -13548.388    266.61248    266.61248    31342.802    31342.802   -3703.8489   -3703.8489 
Loop time of 132.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.837 hours/ns, 7.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    | 132        | 132        | 132        |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10852    | 0.10852    | 0.10852    |   0.0 |  0.08
Output  | 0.0001576  | 0.0001576  | 0.0001576  |   0.0 |  0.00
Modify  | 0.43621    | 0.43621    | 0.43621    |   0.0 |  0.33
Other   |            | 0.06517    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.270350024224, Press = -4.61944098791909
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13479.498   -13479.498   -13548.388   -13548.388    266.61248    266.61248    31342.802    31342.802   -3703.8489   -3703.8489 
   15000   -13475.115   -13475.115   -13547.333   -13547.333    279.48938    279.48938    31320.031    31320.031   -1426.5316   -1426.5316 
Loop time of 117.989 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.732 ns/day, 32.775 hours/ns, 8.475 timesteps/s
100.0% 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.45     | 117.45     | 117.45     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099082   | 0.099082   | 0.099082   |   0.0 |  0.08
Output  | 0.00042364 | 0.00042364 | 0.00042364 |   0.0 |  0.00
Modify  | 0.37551    | 0.37551    | 0.37551    |   0.0 |  0.32
Other   |            | 0.06079    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.151949002538, Press = -5.32733096136798
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13475.115   -13475.115   -13547.333   -13547.333    279.48938    279.48938    31320.031    31320.031   -1426.5316   -1426.5316 
   16000   -13479.874   -13479.874   -13548.262   -13548.262    264.66868    264.66868      31311.6      31311.6   -1108.8495   -1108.8495 
Loop time of 118.305 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.730 ns/day, 32.863 hours/ns, 8.453 timesteps/s
100.0% 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.77     | 117.77     | 117.77     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098664   | 0.098664   | 0.098664   |   0.0 |  0.08
Output  | 0.00015758 | 0.00015758 | 0.00015758 |   0.0 |  0.00
Modify  | 0.37432    | 0.37432    | 0.37432    |   0.0 |  0.32
Other   |            | 0.0612     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.091077571613, Press = -5.28126908369227
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13479.874   -13479.874   -13548.262   -13548.262    264.66868    264.66868      31311.6      31311.6   -1108.8495   -1108.8495 
   17000   -13477.247   -13477.247   -13547.349   -13547.349    271.30184    271.30184    31319.581    31319.581   -1507.3597   -1507.3597 
Loop time of 115.453 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.748 ns/day, 32.070 hours/ns, 8.662 timesteps/s
100.0% 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.94     | 114.94     | 114.94     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09752    | 0.09752    | 0.09752    |   0.0 |  0.08
Output  | 0.00015501 | 0.00015501 | 0.00015501 |   0.0 |  0.00
Modify  | 0.35851    | 0.35851    | 0.35851    |   0.0 |  0.31
Other   |            | 0.05936    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.110639331565, Press = -5.81159693278676
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13477.247   -13477.247   -13547.349   -13547.349    271.30184    271.30184    31319.581    31319.581   -1507.3597   -1507.3597 
   18000   -13477.279   -13477.279   -13546.952   -13546.952    269.64155    269.64155    31323.203    31323.203    -1598.823    -1598.823 
Loop time of 113.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.519 hours/ns, 8.813 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.97     | 112.97     | 112.97     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094954   | 0.094954   | 0.094954   |   0.0 |  0.08
Output  | 0.00015625 | 0.00015625 | 0.00015625 |   0.0 |  0.00
Modify  | 0.34815    | 0.34815    | 0.34815    |   0.0 |  0.31
Other   |            | 0.05885    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.993604162656, Press = -7.51034737820157
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13477.279   -13477.279   -13546.952   -13546.952    269.64155    269.64155    31323.203    31323.203    -1598.823    -1598.823 
   19000   -13477.118   -13477.118   -13547.372   -13547.372    271.89045    271.89045    31308.669    31308.669   -607.72106   -607.72106 
Loop time of 113.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.448 hours/ns, 8.833 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.71     | 112.71     | 112.71     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095249   | 0.095249   | 0.095249   |   0.0 |  0.08
Output  | 0.00015841 | 0.00015841 | 0.00015841 |   0.0 |  0.00
Modify  | 0.34844    | 0.34844    | 0.34844    |   0.0 |  0.31
Other   |            | 0.05859    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.051932949251, Press = -8.12045405097941
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13477.118   -13477.118   -13547.372   -13547.372    271.89045    271.89045    31308.669    31308.669   -607.72106   -607.72106 
   20000   -13477.658   -13477.658   -13549.013   -13549.013    276.14912    276.14912    31296.744    31296.744    195.56554    195.56554 
Loop time of 113.675 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.576 hours/ns, 8.797 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.17     | 113.17     | 113.17     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09539    | 0.09539    | 0.09539    |   0.0 |  0.08
Output  | 0.00015677 | 0.00015677 | 0.00015677 |   0.0 |  0.00
Modify  | 0.35041    | 0.35041    | 0.35041    |   0.0 |  0.31
Other   |            | 0.05841    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.041411357491, Press = -4.10868196193605
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13477.658   -13477.658   -13549.013   -13549.013    276.14912    276.14912    31296.744    31296.744    195.56554    195.56554 
   21000   -13477.063   -13477.063   -13548.027   -13548.027    274.63722    274.63722    31289.346    31289.346    1163.6256    1163.6256 
Loop time of 114.128 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.702 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.62     | 113.62     | 113.62     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095818   | 0.095818   | 0.095818   |   0.0 |  0.08
Output  | 0.00015808 | 0.00015808 | 0.00015808 |   0.0 |  0.00
Modify  | 0.35157    | 0.35157    | 0.35157    |   0.0 |  0.31
Other   |            | 0.05843    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.131202142703, Press = -2.23060247364869
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13477.063   -13477.063   -13548.027   -13548.027    274.63722    274.63722    31289.346    31289.346    1163.6256    1163.6256 
   22000   -13480.909   -13480.909   -13549.093   -13549.093    263.87802    263.87802    31271.946    31271.946    2267.0102    2267.0102 
Loop time of 113.892 on 1 procs for 1000 steps with 2000 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.39     | 113.39     | 113.39     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095318   | 0.095318   | 0.095318   |   0.0 |  0.08
Output  | 0.00015877 | 0.00015877 | 0.00015877 |   0.0 |  0.00
Modify  | 0.35079    | 0.35079    | 0.35079    |   0.0 |  0.31
Other   |            | 0.05806    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.143493624699, Press = -1.60977721291822
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13480.909   -13480.909   -13549.093   -13549.093    263.87802    263.87802    31271.946    31271.946    2267.0102    2267.0102 
   23000   -13477.267   -13477.267   -13549.399   -13549.399    279.15767    279.15767    31266.657    31266.657    2720.4751    2720.4751 
Loop time of 113.888 on 1 procs for 1000 steps with 2000 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.38     | 113.38     | 113.38     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095489   | 0.095489   | 0.095489   |   0.0 |  0.08
Output  | 0.00015761 | 0.00015761 | 0.00015761 |   0.0 |  0.00
Modify  | 0.35065    | 0.35065    | 0.35065    |   0.0 |  0.31
Other   |            | 0.05807    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.200643395041, Press = 0.151623908482774
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13477.267   -13477.267   -13549.399   -13549.399    279.15767    279.15767    31266.657    31266.657    2720.4751    2720.4751 
   24000   -13478.248   -13478.248   -13548.925   -13548.925    273.52717    273.52717    31274.643    31274.643    2146.4412    2146.4412 
Loop time of 114.137 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.705 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.63     | 113.63     | 113.63     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095919   | 0.095919   | 0.095919   |   0.0 |  0.08
Output  | 0.0001848  | 0.0001848  | 0.0001848  |   0.0 |  0.00
Modify  | 0.35003    | 0.35003    | 0.35003    |   0.0 |  0.31
Other   |            | 0.05772    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.292888593957, Press = 1.55483565092887
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13478.248   -13478.248   -13548.925   -13548.925    273.52717    273.52717    31274.643    31274.643    2146.4412    2146.4412 
   25000   -13474.105   -13474.105   -13547.383   -13547.383    283.59046    283.59046    31307.024    31307.024    -270.5986    -270.5986 
Loop time of 114.267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.741 hours/ns, 8.751 timesteps/s
100.0% 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.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095547   | 0.095547   | 0.095547   |   0.0 |  0.08
Output  | 0.00015882 | 0.00015882 | 0.00015882 |   0.0 |  0.00
Modify  | 0.35086    | 0.35086    | 0.35086    |   0.0 |  0.31
Other   |            | 0.05795    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.436331695566, Press = -0.217585312472352
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13474.105   -13474.105   -13547.383   -13547.383    283.59046    283.59046    31307.024    31307.024    -270.5986    -270.5986 
   26000   -13476.321   -13476.321   -13546.493   -13546.493    271.57095    271.57095    31310.177    31310.177   -677.30675   -677.30675 
Loop time of 114.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.690 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.58     | 113.58     | 113.58     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096071   | 0.096071   | 0.096071   |   0.0 |  0.08
Output  | 0.0001582  | 0.0001582  | 0.0001582  |   0.0 |  0.00
Modify  | 0.35012    | 0.35012    | 0.35012    |   0.0 |  0.31
Other   |            | 0.05757    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.466179669238, Press = -1.22217579406225
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13476.321   -13476.321   -13546.493   -13546.493    271.57095    271.57095    31310.177    31310.177   -677.30675   -677.30675 
   27000   -13477.283   -13477.283   -13548.227   -13548.227    274.55965    274.55965    31307.013    31307.013   -591.34945   -591.34945 
Loop time of 114.05 on 1 procs for 1000 steps with 2000 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.55     | 113.55     | 113.55     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095816   | 0.095816   | 0.095816   |   0.0 |  0.08
Output  | 0.00016088 | 0.00016088 | 0.00016088 |   0.0 |  0.00
Modify  | 0.3508     | 0.3508     | 0.3508     |   0.0 |  0.31
Other   |            | 0.05778    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.568990789736, Press = -1.85599395030858
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13477.283   -13477.283   -13548.227   -13548.227    274.55965    274.55965    31307.013    31307.013   -591.34945   -591.34945 
   28000   -13474.486   -13474.486   -13546.509   -13546.509    278.73569    278.73569    31306.262    31306.262    -204.7251    -204.7251 
Loop time of 116.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.744 ns/day, 32.270 hours/ns, 8.608 timesteps/s
100.0% 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.66     | 115.66     | 115.66     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098113   | 0.098113   | 0.098113   |   0.0 |  0.08
Output  | 0.00019656 | 0.00019656 | 0.00019656 |   0.0 |  0.00
Modify  | 0.36067    | 0.36067    | 0.36067    |   0.0 |  0.31
Other   |            | 0.0585     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.584728098325, Press = -1.79310017985656
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13474.486   -13474.486   -13546.509   -13546.509    278.73569    278.73569    31306.262    31306.262    -204.7251    -204.7251 
   29000   -13478.597   -13478.597   -13548.362   -13548.362    269.99894    269.99894    31297.019    31297.019    175.39708    175.39708 
Loop time of 133.162 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.989 hours/ns, 7.510 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    | 132.55     | 132.55     | 132.55     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10831    | 0.10831    | 0.10831    |   0.0 |  0.08
Output  | 0.00020135 | 0.00020135 | 0.00020135 |   0.0 |  0.00
Modify  | 0.43823    | 0.43823    | 0.43823    |   0.0 |  0.33
Other   |            | 0.06635    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.649661280162, Press = -1.74686399528315
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13478.597   -13478.597   -13548.362   -13548.362    269.99894    269.99894    31297.019    31297.019    175.39708    175.39708 
   30000   -13476.016   -13476.016   -13545.829   -13545.829    270.18253    270.18253    31298.293    31298.293    503.20366    503.20366 
Loop time of 128.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.802 hours/ns, 7.759 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    | 128.3      | 128.3      | 128.3      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10591    | 0.10591    | 0.10591    |   0.0 |  0.08
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.41934    | 0.41934    | 0.41934    |   0.0 |  0.33
Other   |            | 0.06484    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.771969382034, Press = -1.55429626060031
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13476.016   -13476.016   -13545.829   -13545.829    270.18253    270.18253    31298.293    31298.293    503.20366    503.20366 
   31000   -13476.204   -13476.204   -13546.591   -13546.591    272.40667    272.40667    31304.402    31304.402   -153.59283   -153.59283 
Loop time of 132.453 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.793 hours/ns, 7.550 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.84     | 131.84     | 131.84     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1093     | 0.1093     | 0.1093     |   0.0 |  0.08
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.43795    | 0.43795    | 0.43795    |   0.0 |  0.33
Other   |            | 0.06644    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.785845392772, Press = -1.16076037070551
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13476.204   -13476.204   -13546.591   -13546.591    272.40667    272.40667    31304.402    31304.402   -153.59283   -153.59283 
   32000   -13478.856   -13478.856   -13548.394   -13548.394    269.12015    269.12015     31311.76     31311.76   -1044.9751   -1044.9751 
Loop time of 124.629 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.693 ns/day, 34.619 hours/ns, 8.024 timesteps/s
100.0% 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.06     | 124.06     | 124.06     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10351    | 0.10351    | 0.10351    |   0.0 |  0.08
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.4033     | 0.4033     | 0.4033     |   0.0 |  0.32
Other   |            | 0.06296    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.847381479025, Press = -1.03921097194676
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13478.856   -13478.856   -13548.394   -13548.394    269.12015    269.12015     31311.76     31311.76   -1044.9751   -1044.9751 
   33000   -13475.558   -13475.558    -13544.88    -13544.88    268.28079    268.28079    31323.631    31323.631   -1670.1237   -1670.1237 
Loop time of 113.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.494 hours/ns, 8.820 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.88     | 112.88     | 112.88     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094791   | 0.094791   | 0.094791   |   0.0 |  0.08
Output  | 0.00015467 | 0.00015467 | 0.00015467 |   0.0 |  0.00
Modify  | 0.34803    | 0.34803    | 0.34803    |   0.0 |  0.31
Other   |            | 0.05842    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.806672678123, Press = -0.976661183988871
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13475.558   -13475.558    -13544.88    -13544.88    268.28079    268.28079    31323.631    31323.631   -1670.1237   -1670.1237 
   34000   -13479.111   -13479.111   -13547.017   -13547.017     262.8014     262.8014    31333.587    31333.587   -2859.2129   -2859.2129 
Loop time of 113.151 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.431 hours/ns, 8.838 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.65     | 112.65     | 112.65     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095193   | 0.095193   | 0.095193   |   0.0 |  0.08
Output  | 0.00019025 | 0.00019025 | 0.00019025 |   0.0 |  0.00
Modify  | 0.34682    | 0.34682    | 0.34682    |   0.0 |  0.31
Other   |            | 0.05821    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.819367072006, Press = -1.38844435330754
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13479.111   -13479.111   -13547.017   -13547.017     262.8014     262.8014    31333.587    31333.587   -2859.2129   -2859.2129 
   35000    -13479.98    -13479.98   -13547.116   -13547.116    259.82553    259.82553    31332.863    31332.863   -2680.2062   -2680.2062 
Loop time of 113.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.468 hours/ns, 8.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    | 112.78     | 112.78     | 112.78     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09476    | 0.09476    | 0.09476    |   0.0 |  0.08
Output  | 0.00015599 | 0.00015599 | 0.00015599 |   0.0 |  0.00
Modify  | 0.34843    | 0.34843    | 0.34843    |   0.0 |  0.31
Other   |            | 0.05838    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.819577554659, Press = -2.18291379134759
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -13479.98    -13479.98   -13547.116   -13547.116    259.82553    259.82553    31332.863    31332.863   -2680.2062   -2680.2062 
   36000   -13475.518   -13475.518   -13548.188   -13548.188    281.24189    281.24189     31327.36     31327.36   -2138.0847   -2138.0847 
Loop time of 113.462 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.517 hours/ns, 8.814 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.96     | 112.96     | 112.96     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094298   | 0.094298   | 0.094298   |   0.0 |  0.08
Output  | 0.00015561 | 0.00015561 | 0.00015561 |   0.0 |  0.00
Modify  | 0.34827    | 0.34827    | 0.34827    |   0.0 |  0.31
Other   |            | 0.05829    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.805763407219, Press = -2.87711605303943
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13475.518   -13475.518   -13548.188   -13548.188    281.24189    281.24189     31327.36     31327.36   -2138.0847   -2138.0847 
   37000     -13477.3     -13477.3   -13548.835   -13548.835    276.84941    276.84941    31307.873    31307.873   -600.67066   -600.67066 
Loop time of 120.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.454 hours/ns, 8.303 timesteps/s
100.0% 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.9      | 119.9      | 119.9      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099896   | 0.099896   | 0.099896   |   0.0 |  0.08
Output  | 0.00015664 | 0.00015664 | 0.00015664 |   0.0 |  0.00
Modify  | 0.37964    | 0.37964    | 0.37964    |   0.0 |  0.32
Other   |            | 0.06092    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.802065980113, Press = -3.50334694327526
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000     -13477.3     -13477.3   -13548.835   -13548.835    276.84941    276.84941    31307.873    31307.873   -600.67066   -600.67066 
   38000    -13477.13    -13477.13   -13546.547   -13546.547    268.65285    268.65285    31290.222    31290.222    1170.4638    1170.4638 
Loop time of 131.788 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.608 hours/ns, 7.588 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    | 131.18     | 131.18     | 131.18     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10806    | 0.10806    | 0.10806    |   0.0 |  0.08
Output  | 0.00015434 | 0.00015434 | 0.00015434 |   0.0 |  0.00
Modify  | 0.4355     | 0.4355     | 0.4355     |   0.0 |  0.33
Other   |            | 0.06564    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.892717122916, Press = -2.28816654607478
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -13477.13    -13477.13   -13546.547   -13546.547    268.65285    268.65285    31290.222    31290.222    1170.4638    1170.4638 
   39000   -13477.373   -13477.373   -13547.819   -13547.819    272.63323    272.63323    31291.134    31291.134    857.28338    857.28338 
Loop time of 132.179 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.716 hours/ns, 7.566 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    | 131.56     | 131.56     | 131.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10911    | 0.10911    | 0.10911    |   0.0 |  0.08
Output  | 0.00015415 | 0.00015415 | 0.00015415 |   0.0 |  0.00
Modify  | 0.44166    | 0.44166    | 0.44166    |   0.0 |  0.33
Other   |            | 0.06668    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869797965843, Press = -1.56343285022924
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13477.373   -13477.373   -13547.819   -13547.819    272.63323    272.63323    31291.134    31291.134    857.28338    857.28338 
   40000   -13478.594   -13478.594   -13548.772   -13548.772    271.59466    271.59466    31281.319    31281.319    1506.2963    1506.2963 
Loop time of 132.85 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.903 hours/ns, 7.527 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    | 132.24     | 132.24     | 132.24     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10824    | 0.10824    | 0.10824    |   0.0 |  0.08
Output  | 0.00019579 | 0.00019579 | 0.00019579 |   0.0 |  0.00
Modify  | 0.43368    | 0.43368    | 0.43368    |   0.0 |  0.33
Other   |            | 0.06658    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869697604992, Press = -1.06150860984212
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13478.594   -13478.594   -13548.772   -13548.772    271.59466    271.59466    31281.319    31281.319    1506.2963    1506.2963 
   41000   -13479.386   -13479.386   -13547.265   -13547.265    262.69946    262.69946    31269.156    31269.156    2603.2263    2603.2263 
Loop time of 132.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.843 hours/ns, 7.540 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    | 132.02     | 132.02     | 132.02     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10933    | 0.10933    | 0.10933    |   0.0 |  0.08
Output  | 0.00045406 | 0.00045406 | 0.00045406 |   0.0 |  0.00
Modify  | 0.44056    | 0.44056    | 0.44056    |   0.0 |  0.33
Other   |            | 0.06648    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.878925576284, Press = -0.10454733512822
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13479.386   -13479.386   -13547.265   -13547.265    262.69946    262.69946    31269.156    31269.156    2603.2263    2603.2263 
   42000   -13477.177   -13477.177   -13547.622   -13547.622     272.6297     272.6297    31270.713    31270.713    2429.8792    2429.8792 
Loop time of 132.415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.782 hours/ns, 7.552 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.8      | 131.8      | 131.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10964    | 0.10964    | 0.10964    |   0.0 |  0.08
Output  | 0.00015785 | 0.00015785 | 0.00015785 |   0.0 |  0.00
Modify  | 0.43751    | 0.43751    | 0.43751    |   0.0 |  0.33
Other   |            | 0.06659    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.84836805793, Press = 1.62299539016806
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13477.177   -13477.177   -13547.622   -13547.622     272.6297     272.6297    31270.713    31270.713    2429.8792    2429.8792 
   43000   -13477.183   -13477.183   -13548.478   -13548.478    275.91755    275.91755    31298.377    31298.377    168.94424    168.94424 
Loop time of 130.937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.371 hours/ns, 7.637 timesteps/s
100.0% 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.33     | 130.33     | 130.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10811    | 0.10811    | 0.10811    |   0.0 |  0.08
Output  | 0.00015559 | 0.00015559 | 0.00015559 |   0.0 |  0.00
Modify  | 0.42958    | 0.42958    | 0.42958    |   0.0 |  0.33
Other   |            | 0.06607    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.849981954238, Press = 0.33009544313341
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13477.183   -13477.183   -13548.478   -13548.478    275.91755    275.91755    31298.377    31298.377    168.94424    168.94424 
   44000   -13474.207   -13474.207    -13545.87    -13545.87    277.34538    277.34538     31316.64     31316.64    -903.9209    -903.9209 
Loop time of 133.249 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.014 hours/ns, 7.505 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    | 132.63     | 132.63     | 132.63     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11129    | 0.11129    | 0.11129    |   0.0 |  0.08
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.44208    | 0.44208    | 0.44208    |   0.0 |  0.33
Other   |            | 0.06698    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.870425177887, Press = -0.0534142318961255
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13474.207   -13474.207    -13545.87    -13545.87    277.34538    277.34538     31316.64     31316.64    -903.9209    -903.9209 
   45000   -13476.137   -13476.137   -13546.654   -13546.654    272.90906    272.90906    31326.194    31326.194   -1918.4538   -1918.4538 
Loop time of 127.433 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.398 hours/ns, 7.847 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.85     | 126.85     | 126.85     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10626    | 0.10626    | 0.10626    |   0.0 |  0.08
Output  | 0.00015752 | 0.00015752 | 0.00015752 |   0.0 |  0.00
Modify  | 0.41542    | 0.41542    | 0.41542    |   0.0 |  0.33
Other   |            | 0.06472    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.856371924881, Press = -0.504895180594692
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13476.137   -13476.137   -13546.654   -13546.654    272.90906    272.90906    31326.194    31326.194   -1918.4538   -1918.4538 
   46000   -13480.458   -13480.458   -13550.866   -13550.866    272.48822    272.48822    31325.908    31325.908    -2545.381    -2545.381 
Loop time of 117.174 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.737 ns/day, 32.548 hours/ns, 8.534 timesteps/s
100.0% 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.64     | 116.64     | 116.64     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098314   | 0.098314   | 0.098314   |   0.0 |  0.08
Output  | 0.00020694 | 0.00020694 | 0.00020694 |   0.0 |  0.00
Modify  | 0.36998    | 0.36998    | 0.36998    |   0.0 |  0.32
Other   |            | 0.061      |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.822779392938, Press = -0.895365504949704
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13480.458   -13480.458   -13550.866   -13550.866    272.48822    272.48822    31325.908    31325.908    -2545.381    -2545.381 
   47000   -13476.491   -13476.491   -13547.634   -13547.634     275.3293     275.3293    31356.074    31356.074   -4431.4092   -4431.4092 
Loop time of 119.424 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.173 hours/ns, 8.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    | 118.88     | 118.88     | 118.88     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10082    | 0.10082    | 0.10082    |   0.0 |  0.08
Output  | 0.00015755 | 0.00015755 | 0.00015755 |   0.0 |  0.00
Modify  | 0.37969    | 0.37969    | 0.37969    |   0.0 |  0.32
Other   |            | 0.06099    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.823869848631, Press = -1.68364099062311
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13476.491   -13476.491   -13547.634   -13547.634     275.3293     275.3293    31356.074    31356.074   -4431.4092   -4431.4092 
   48000   -13479.987   -13479.987   -13548.517   -13548.517     265.2182     265.2182    31336.856    31336.856   -2961.5206   -2961.5206 
Loop time of 113.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.513 hours/ns, 8.815 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.94     | 112.94     | 112.94     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09606    | 0.09606    | 0.09606    |   0.0 |  0.08
Output  | 0.00015587 | 0.00015587 | 0.00015587 |   0.0 |  0.00
Modify  | 0.3522     | 0.3522     | 0.3522     |   0.0 |  0.31
Other   |            | 0.05875    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.78099338059, Press = -2.01198653252671
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -13479.987   -13479.987   -13548.517   -13548.517     265.2182     265.2182    31336.856    31336.856   -2961.5206   -2961.5206 
   49000   -13475.473   -13475.473   -13544.959   -13544.959    268.91785    268.91785    31313.696    31313.696   -441.45457   -441.45457 
Loop time of 127.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.541 hours/ns, 7.816 timesteps/s
100.0% 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.36     | 127.36     | 127.36     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10617    | 0.10617    | 0.10617    |   0.0 |  0.08
Output  | 0.00015696 | 0.00015696 | 0.00015696 |   0.0 |  0.00
Modify  | 0.41947    | 0.41947    | 0.41947    |   0.0 |  0.33
Other   |            | 0.06464    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.769658978587, Press = -1.30248924953768
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13475.473   -13475.473   -13544.959   -13544.959    268.91785    268.91785    31313.696    31313.696   -441.45457   -441.45457 
   50000   -13477.115   -13477.115   -13546.792   -13546.792    269.65763    269.65763    31309.229    31309.229   -384.13122   -384.13122 
Loop time of 132.258 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.738 hours/ns, 7.561 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    | 131.64     | 131.64     | 131.64     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10873    | 0.10873    | 0.10873    |   0.0 |  0.08
Output  | 0.0002092  | 0.0002092  | 0.0002092  |   0.0 |  0.00
Modify  | 0.43868    | 0.43868    | 0.43868    |   0.0 |  0.33
Other   |            | 0.06688    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.778689290022, Press = -1.40041667223858
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13477.115   -13477.115   -13546.792   -13546.792    269.65763    269.65763    31309.229    31309.229   -384.13122   -384.13122 
   51000   -13474.076   -13474.076    -13545.88    -13545.88    277.88783    277.88783    31306.353    31306.353    127.59282    127.59282 
Loop time of 114.684 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.753 ns/day, 31.857 hours/ns, 8.720 timesteps/s
100.0% 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.17     | 114.17     | 114.17     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096733   | 0.096733   | 0.096733   |   0.0 |  0.08
Output  | 0.00016046 | 0.00016046 | 0.00016046 |   0.0 |  0.00
Modify  | 0.355      | 0.355      | 0.355      |   0.0 |  0.31
Other   |            | 0.05925    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.789933749992, Press = -1.70543588511748
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13474.076   -13474.076    -13545.88    -13545.88    277.88783    277.88783    31306.353    31306.353    127.59282    127.59282 
   52000   -13478.029   -13478.029   -13549.165   -13549.165    275.30235    275.30235    31289.088    31289.088    997.01578    997.01578 
Loop time of 127.096 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.305 hours/ns, 7.868 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.51     | 126.51     | 126.51     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10476    | 0.10476    | 0.10476    |   0.0 |  0.08
Output  | 0.00015756 | 0.00015756 | 0.00015756 |   0.0 |  0.00
Modify  | 0.41284    | 0.41284    | 0.41284    |   0.0 |  0.32
Other   |            | 0.06484    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.837988228879, Press = -1.84796123042415
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13478.029   -13478.029   -13549.165   -13549.165    275.30235    275.30235    31289.088    31289.088    997.01578    997.01578 
   53000   -13476.965   -13476.965   -13548.333   -13548.333    276.19869    276.19869    31265.216    31265.216    2957.9303    2957.9303 
Loop time of 131.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.620 hours/ns, 7.585 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    | 131.22     | 131.22     | 131.22     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10964    | 0.10964    | 0.10964    |   0.0 |  0.08
Output  | 0.00015329 | 0.00015329 | 0.00015329 |   0.0 |  0.00
Modify  | 0.43908    | 0.43908    | 0.43908    |   0.0 |  0.33
Other   |            | 0.06641    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.859528655943, Press = -1.93454818241427
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13476.965   -13476.965   -13548.333   -13548.333    276.19869    276.19869    31265.216    31265.216    2957.9303    2957.9303 
   54000   -13477.379   -13477.379   -13548.797   -13548.797    276.39524    276.39524    31270.076    31270.076    2498.9566    2498.9566 
Loop time of 132.145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.707 hours/ns, 7.567 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.53     | 131.53     | 131.53     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10992    | 0.10992    | 0.10992    |   0.0 |  0.08
Output  | 0.00015775 | 0.00015775 | 0.00015775 |   0.0 |  0.00
Modify  | 0.43964    | 0.43964    | 0.43964    |   0.0 |  0.33
Other   |            | 0.06674    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.815036599009, Press = -0.97274517112453
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13477.379   -13477.379   -13548.797   -13548.797    276.39524    276.39524    31270.076    31270.076    2498.9566    2498.9566 
   55000   -13478.518   -13478.518   -13548.459   -13548.459    270.67968    270.67968    31275.198    31275.198    2051.8779    2051.8779 
Loop time of 132.313 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.753 hours/ns, 7.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    | 131.7      | 131.7      | 131.7      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1089     | 0.1089     | 0.1089     |   0.0 |  0.08
Output  | 0.00015681 | 0.00015681 | 0.00015681 |   0.0 |  0.00
Modify  | 0.43874    | 0.43874    | 0.43874    |   0.0 |  0.33
Other   |            | 0.06651    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.811506170856, Press = -0.520861410613635
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13478.518   -13478.518   -13548.459   -13548.459    270.67968    270.67968    31275.198    31275.198    2051.8779    2051.8779 
   56000   -13475.892   -13475.892   -13548.243   -13548.243    280.00708    280.00708    31282.954    31282.954    1515.9236    1515.9236 
Loop time of 128.045 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.568 hours/ns, 7.810 timesteps/s
100.0% 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.46     | 127.46     | 127.46     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10615    | 0.10615    | 0.10615    |   0.0 |  0.08
Output  | 0.00015565 | 0.00015565 | 0.00015565 |   0.0 |  0.00
Modify  | 0.4164     | 0.4164     | 0.4164     |   0.0 |  0.33
Other   |            | 0.06516    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.79669621743, Press = -0.249365165395553
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -13475.892   -13475.892   -13548.243   -13548.243    280.00708    280.00708    31282.954    31282.954    1515.9236    1515.9236 
   57000   -13479.797   -13479.797   -13547.598   -13547.598    262.39747    262.39747    31274.916    31274.916    2094.4775    2094.4775 
Loop time of 130.415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.662 ns/day, 36.226 hours/ns, 7.668 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    | 129.81     | 129.81     | 129.81     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10871    | 0.10871    | 0.10871    |   0.0 |  0.08
Output  | 0.00021492 | 0.00021492 | 0.00021492 |   0.0 |  0.00
Modify  | 0.42722    | 0.42722    | 0.42722    |   0.0 |  0.33
Other   |            | 0.06586    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.759293387204, Press = -0.0961454740760972
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13479.797   -13479.797   -13547.598   -13547.598    262.39747    262.39747    31274.916    31274.916    2094.4775    2094.4775 
   58000    -13477.38    -13477.38   -13547.366   -13547.366    270.85199    270.85199    31282.535    31282.535    1569.5948    1569.5948 
Loop time of 128.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.733 hours/ns, 7.774 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    | 128.04     | 128.04     | 128.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10681    | 0.10681    | 0.10681    |   0.0 |  0.08
Output  | 0.00019973 | 0.00019973 | 0.00019973 |   0.0 |  0.00
Modify  | 0.42146    | 0.42146    | 0.42146    |   0.0 |  0.33
Other   |            | 0.06476    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.746190181186, Press = 0.41650914622696
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000    -13477.38    -13477.38   -13547.366   -13547.366    270.85199    270.85199    31282.535    31282.535    1569.5948    1569.5948 
   59000   -13474.734   -13474.734   -13547.154   -13547.154    280.27312    280.27312    31299.371    31299.371    329.66231    329.66231 
Loop time of 124.257 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.516 hours/ns, 8.048 timesteps/s
100.0% 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.69     | 123.69     | 123.69     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1031     | 0.1031     | 0.1031     |   0.0 |  0.08
Output  | 0.00024313 | 0.00024313 | 0.00024313 |   0.0 |  0.00
Modify  | 0.40312    | 0.40312    | 0.40312    |   0.0 |  0.32
Other   |            | 0.06395    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.72742377037, Press = 1.0839334655638
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -13474.734   -13474.734   -13547.154   -13547.154    280.27312    280.27312    31299.371    31299.371    329.66231    329.66231 
   60000   -13475.403   -13475.403   -13546.432   -13546.432    274.88952    274.88952    31313.187    31313.187   -832.76692   -832.76692 
Loop time of 125.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 34.965 hours/ns, 7.945 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    | 125.3      | 125.3      | 125.3      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1042     | 0.1042     | 0.1042     |   0.0 |  0.08
Output  | 0.0001561  | 0.0001561  | 0.0001561  |   0.0 |  0.00
Modify  | 0.40735    | 0.40735    | 0.40735    |   0.0 |  0.32
Other   |            | 0.06408    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.740405536073, Press = 0.292460896683026
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -13475.403   -13475.403   -13546.432   -13546.432    274.88952    274.88952    31313.187    31313.187   -832.76692   -832.76692 
   61000    -13474.22    -13474.22   -13546.414   -13546.414    279.39622    279.39622    31320.231    31320.231   -1366.8116   -1366.8116 
Loop time of 132.356 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.766 hours/ns, 7.555 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    | 131.74     | 131.74     | 131.74     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10874    | 0.10874    | 0.10874    |   0.0 |  0.08
Output  | 0.00017335 | 0.00017335 | 0.00017335 |   0.0 |  0.00
Modify  | 0.43856    | 0.43856    | 0.43856    |   0.0 |  0.33
Other   |            | 0.0665     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.746499852715, Press = -0.00384329500482942
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000    -13474.22    -13474.22   -13546.414   -13546.414    279.39622    279.39622    31320.231    31320.231   -1366.8116   -1366.8116 
   62000   -13477.423   -13477.423   -13547.901   -13547.901    272.75461    272.75461    31321.105    31321.105   -1642.0227   -1642.0227 
Loop time of 127.209 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.336 hours/ns, 7.861 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.62     | 126.62     | 126.62     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10614    | 0.10614    | 0.10614    |   0.0 |  0.08
Output  | 0.00015691 | 0.00015691 | 0.00015691 |   0.0 |  0.00
Modify  | 0.41346    | 0.41346    | 0.41346    |   0.0 |  0.33
Other   |            | 0.06526    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.804950337518, Press = -0.312815873583081
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -13477.423   -13477.423   -13547.901   -13547.901    272.75461    272.75461    31321.105    31321.105   -1642.0227   -1642.0227 
   63000   -13476.404   -13476.404   -13548.205   -13548.205    277.87716    277.87716    31328.981    31328.981   -2172.8355   -2172.8355 
Loop time of 121.207 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.668 hours/ns, 8.250 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    | 120.66     | 120.66     | 120.66     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10067    | 0.10067    | 0.10067    |   0.0 |  0.08
Output  | 0.00015579 | 0.00015579 | 0.00015579 |   0.0 |  0.00
Modify  | 0.38273    | 0.38273    | 0.38273    |   0.0 |  0.32
Other   |            | 0.06293    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.798451742546, Press = -0.575092502817578
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -13476.404   -13476.404   -13548.205   -13548.205    277.87716    277.87716    31328.981    31328.981   -2172.8355   -2172.8355 
   64000   -13481.735   -13481.735    -13550.94    -13550.94     267.8313     267.8313    31347.922    31347.922   -4374.3484   -4374.3484 
Loop time of 125.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.687 ns/day, 34.930 hours/ns, 7.952 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    | 125.17     | 125.17     | 125.17     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10426    | 0.10426    | 0.10426    |   0.0 |  0.08
Output  | 0.00025466 | 0.00025466 | 0.00025466 |   0.0 |  0.00
Modify  | 0.40734    | 0.40734    | 0.40734    |   0.0 |  0.32
Other   |            | 0.06449    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.789048132953, Press = -1.25205113338394
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -13481.735   -13481.735    -13550.94    -13550.94     267.8313     267.8313    31347.922    31347.922   -4374.3484   -4374.3484 
   65000    -13476.62    -13476.62     -13545.9     -13545.9    268.12135    268.12135    31341.875    31341.875   -3041.9943   -3041.9943 
Loop time of 118.981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.050 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.44     | 118.44     | 118.44     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10087    | 0.10087    | 0.10087    |   0.0 |  0.08
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.37381    | 0.37381    | 0.37381    |   0.0 |  0.31
Other   |            | 0.06114    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.750199399276, Press = -1.45391080258783
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000    -13476.62    -13476.62     -13545.9     -13545.9    268.12135    268.12135    31341.875    31341.875   -3041.9943   -3041.9943 
   66000   -13478.431   -13478.431   -13547.759   -13547.759    268.30377    268.30377     31312.01     31312.01   -877.51021   -877.51021 
Loop time of 114.017 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.671 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.51     | 113.51     | 113.51     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097235   | 0.097235   | 0.097235   |   0.0 |  0.09
Output  | 0.00014956 | 0.00014956 | 0.00014956 |   0.0 |  0.00
Modify  | 0.35314    | 0.35314    | 0.35314    |   0.0 |  0.31
Other   |            | 0.05788    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.7399879266, Press = -1.00045865647269
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -13478.431   -13478.431   -13547.759   -13547.759    268.30377    268.30377     31312.01     31312.01   -877.51021   -877.51021 
   67000   -13479.185   -13479.185   -13549.833   -13549.833    273.41389    273.41389    31295.799    31295.799    139.73744    139.73744 
Loop time of 113.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.618 hours/ns, 8.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    | 113.32     | 113.32     | 113.32     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097154   | 0.097154   | 0.097154   |   0.0 |  0.09
Output  | 0.00045369 | 0.00045369 | 0.00045369 |   0.0 |  0.00
Modify  | 0.35135    | 0.35135    | 0.35135    |   0.0 |  0.31
Other   |            | 0.05818    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.709324232376, Press = -0.986163195956013
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -13479.185   -13479.185   -13549.833   -13549.833    273.41389    273.41389    31295.799    31295.799    139.73744    139.73744 
   68000   -13477.646   -13477.646   -13549.202   -13549.202    276.93059    276.93059    31288.583    31288.583    1006.8588    1006.8588 
Loop time of 113.74 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.595 hours/ns, 8.792 timesteps/s
100.0% 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.23     | 113.23     | 113.23     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096841   | 0.096841   | 0.096841   |   0.0 |  0.09
Output  | 0.00015576 | 0.00015576 | 0.00015576 |   0.0 |  0.00
Modify  | 0.35236    | 0.35236    | 0.35236    |   0.0 |  0.31
Other   |            | 0.05867    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.727545196362, Press = -0.753131705281867
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -13477.646   -13477.646   -13549.202   -13549.202    276.93059    276.93059    31288.583    31288.583    1006.8588    1006.8588 
   69000   -13479.351   -13479.351   -13549.077   -13549.077     269.8459     269.8459    31278.991    31278.991    1684.5037    1684.5037 
Loop time of 114.055 on 1 procs for 1000 steps with 2000 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.55     | 113.55     | 113.55     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097542   | 0.097542   | 0.097542   |   0.0 |  0.09
Output  | 0.00015591 | 0.00015591 | 0.00015591 |   0.0 |  0.00
Modify  | 0.35298    | 0.35298    | 0.35298    |   0.0 |  0.31
Other   |            | 0.05805    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.722926092778, Press = -0.438769828758299
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -13479.351   -13479.351   -13549.077   -13549.077     269.8459     269.8459    31278.991    31278.991    1684.5037    1684.5037 
   70000    -13475.47    -13475.47   -13546.936   -13546.936    276.58044    276.58044    31259.367    31259.367    3773.7174    3773.7174 
Loop time of 114.062 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.684 hours/ns, 8.767 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.55     | 113.55     | 113.55     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097561   | 0.097561   | 0.097561   |   0.0 |  0.09
Output  | 0.00015498 | 0.00015498 | 0.00015498 |   0.0 |  0.00
Modify  | 0.35366    | 0.35366    | 0.35366    |   0.0 |  0.31
Other   |            | 0.0585     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.704127106554, Press = 0.0195820530340083
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000    -13475.47    -13475.47   -13546.936   -13546.936    276.58044    276.58044    31259.367    31259.367    3773.7174    3773.7174 
   71000    -13477.05    -13477.05    -13549.44    -13549.44    280.15534    280.15534    31258.541    31258.541    3467.1982    3467.1982 
Loop time of 113.771 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.603 hours/ns, 8.790 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.26     | 113.26     | 113.26     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097568   | 0.097568   | 0.097568   |   0.0 |  0.09
Output  | 0.00015663 | 0.00015663 | 0.00015663 |   0.0 |  0.00
Modify  | 0.35424    | 0.35424    | 0.35424    |   0.0 |  0.31
Other   |            | 0.05939    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.711715688752, Press = 0.601137619580544
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000    -13477.05    -13477.05    -13549.44    -13549.44    280.15534    280.15534    31258.541    31258.541    3467.1982    3467.1982 
   72000   -13477.619   -13477.619   -13547.301   -13547.301    269.67654    269.67654    31285.422    31285.422    1373.5963    1373.5963 
Loop time of 113.265 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.463 hours/ns, 8.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    | 112.76     | 112.76     | 112.76     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096586   | 0.096586   | 0.096586   |   0.0 |  0.09
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.35132    | 0.35132    | 0.35132    |   0.0 |  0.31
Other   |            | 0.05889    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.762205778513, Press = 0.339320541668598
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -13477.619   -13477.619   -13547.301   -13547.301    269.67654    269.67654    31285.422    31285.422    1373.5963    1373.5963 
   73000   -13474.381   -13474.381   -13547.271   -13547.271    282.09325    282.09325    31306.002    31306.002   -394.70378   -394.70378 
Loop time of 122.657 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.704 ns/day, 34.071 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.1      | 122.1      | 122.1      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10286    | 0.10286    | 0.10286    |   0.0 |  0.08
Output  | 0.00015564 | 0.00015564 | 0.00015564 |   0.0 |  0.00
Modify  | 0.39426    | 0.39426    | 0.39426    |   0.0 |  0.32
Other   |            | 0.06288    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.784285188572, Press = 0.335821426728046
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -13474.381   -13474.381   -13547.271   -13547.271    282.09325    282.09325    31306.002    31306.002   -394.70378   -394.70378 
   74000   -13478.837   -13478.837   -13550.399   -13550.399    276.95395    276.95395    31309.145    31309.145   -1057.4235   -1057.4235 
Loop time of 125.506 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.863 hours/ns, 7.968 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.93     | 124.93     | 124.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10323    | 0.10323    | 0.10323    |   0.0 |  0.08
Output  | 0.00015866 | 0.00015866 | 0.00015866 |   0.0 |  0.00
Modify  | 0.40488    | 0.40488    | 0.40488    |   0.0 |  0.32
Other   |            | 0.0637     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.822225571751, Press = 0.230027644603124
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -13478.837   -13478.837   -13550.399   -13550.399    276.95395    276.95395    31309.145    31309.145   -1057.4235   -1057.4235 
   75000   -13477.728   -13477.728   -13547.945   -13547.945     271.7459     271.7459    31325.135    31325.135   -1934.0512   -1934.0512 
Loop time of 128.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.629 hours/ns, 7.796 timesteps/s
100.0% 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.67     | 127.67     | 127.67     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10746    | 0.10746    | 0.10746    |   0.0 |  0.08
Output  | 0.00015754 | 0.00015754 | 0.00015754 |   0.0 |  0.00
Modify  | 0.42425    | 0.42425    | 0.42425    |   0.0 |  0.33
Other   |            | 0.06503    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.844324084107, Press = 0.119747600248309
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -13477.728   -13477.728   -13547.945   -13547.945     271.7459     271.7459    31325.135    31325.135   -1934.0512   -1934.0512 
   76000   -13474.188   -13474.188   -13545.125   -13545.125    274.53327    274.53327    31366.082    31366.082   -5180.2005   -5180.2005 
Loop time of 132.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.801 hours/ns, 7.548 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.87     | 131.87     | 131.87     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11021    | 0.11021    | 0.11021    |   0.0 |  0.08
Output  | 0.00015607 | 0.00015607 | 0.00015607 |   0.0 |  0.00
Modify  | 0.43723    | 0.43723    | 0.43723    |   0.0 |  0.33
Other   |            | 0.0662     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.84763530142, Press = -0.0467107914274953
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -13474.188   -13474.188   -13545.125   -13545.125    274.53327    274.53327    31366.082    31366.082   -5180.2005   -5180.2005 
   77000   -13478.588   -13478.588   -13548.476   -13548.476     270.4731     270.4731    31327.732    31327.732   -2406.3723   -2406.3723 
Loop time of 132.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.783 hours/ns, 7.552 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.8      | 131.8      | 131.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10999    | 0.10999    | 0.10999    |   0.0 |  0.08
Output  | 0.00016122 | 0.00016122 | 0.00016122 |   0.0 |  0.00
Modify  | 0.43919    | 0.43919    | 0.43919    |   0.0 |  0.33
Other   |            | 0.0661     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8759157249, Press = -0.453356573998677
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -13478.588   -13478.588   -13548.476   -13548.476     270.4731     270.4731    31327.732    31327.732   -2406.3723   -2406.3723 
   78000   -13476.132   -13476.132   -13546.785   -13546.785    273.43406    273.43406     31314.88     31314.88   -910.77925   -910.77925 
Loop time of 132.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.781 hours/ns, 7.552 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.8      | 131.8      | 131.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10947    | 0.10947    | 0.10947    |   0.0 |  0.08
Output  | 0.00015614 | 0.00015614 | 0.00015614 |   0.0 |  0.00
Modify  | 0.43765    | 0.43765    | 0.43765    |   0.0 |  0.33
Other   |            | 0.06644    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.889590650936, Press = -0.559698212300051
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -13476.132   -13476.132   -13546.785   -13546.785    273.43406    273.43406     31314.88     31314.88   -910.77925   -910.77925 
   79000   -13481.521   -13481.521   -13550.368   -13550.368    266.44795    266.44795    31297.597    31297.597   -58.251546   -58.251546 
Loop time of 120.594 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.498 hours/ns, 8.292 timesteps/s
100.0% 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.04     | 120.04     | 120.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1009     | 0.1009     | 0.1009     |   0.0 |  0.08
Output  | 0.00015768 | 0.00015768 | 0.00015768 |   0.0 |  0.00
Modify  | 0.38577    | 0.38577    | 0.38577    |   0.0 |  0.32
Other   |            | 0.0626     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.881913013715, Press = -0.678968191345242
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -13481.521   -13481.521   -13550.368   -13550.368    266.44795    266.44795    31297.597    31297.597   -58.251546   -58.251546 
   80000   -13476.836   -13476.836   -13546.735   -13546.735     270.5151     270.5151    31288.443    31288.443    1010.0456    1010.0456 
Loop time of 118.891 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.025 hours/ns, 8.411 timesteps/s
100.0% 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.35     | 118.35     | 118.35     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1005     | 0.1005     | 0.1005     |   0.0 |  0.08
Output  | 0.00015638 | 0.00015638 | 0.00015638 |   0.0 |  0.00
Modify  | 0.3759     | 0.3759     | 0.3759     |   0.0 |  0.32
Other   |            | 0.06183    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.868415653238, Press = -0.697021261458732
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -13476.836   -13476.836   -13546.735   -13546.735     270.5151     270.5151    31288.443    31288.443    1010.0456    1010.0456 
   81000   -13477.495   -13477.495   -13548.678   -13548.678    275.48832    275.48832    31259.516    31259.516    3172.6217    3172.6217 
Loop time of 113.434 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.509 hours/ns, 8.816 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.93     | 112.93     | 112.93     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095787   | 0.095787   | 0.095787   |   0.0 |  0.08
Output  | 0.0001551  | 0.0001551  | 0.0001551  |   0.0 |  0.00
Modify  | 0.35047    | 0.35047    | 0.35047    |   0.0 |  0.31
Other   |            | 0.05952    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.839235751283, Press = -0.856139108617214
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -13477.495   -13477.495   -13548.678   -13548.678    275.48832    275.48832    31259.516    31259.516    3172.6217    3172.6217 
   82000   -13478.194   -13478.194   -13548.773   -13548.773    273.14499    273.14499    31262.461    31262.461    3014.2723    3014.2723 
Loop time of 113.5 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.528 hours/ns, 8.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    | 112.99     | 112.99     | 112.99     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096441   | 0.096441   | 0.096441   |   0.0 |  0.08
Output  | 0.00015894 | 0.00015894 | 0.00015894 |   0.0 |  0.00
Modify  | 0.35052    | 0.35052    | 0.35052    |   0.0 |  0.31
Other   |            | 0.05912    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.855646513384, Press = -0.442463709573984
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -13478.194   -13478.194   -13548.773   -13548.773    273.14499    273.14499    31262.461    31262.461    3014.2723    3014.2723 
   83000   -13474.152   -13474.152    -13546.88    -13546.88    281.46552    281.46552     31283.34     31283.34    1595.1794    1595.1794 
Loop time of 113.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.427 hours/ns, 8.839 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.63     | 112.63     | 112.63     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096258   | 0.096258   | 0.096258   |   0.0 |  0.09
Output  | 0.00015645 | 0.00015645 | 0.00015645 |   0.0 |  0.00
Modify  | 0.35015    | 0.35015    | 0.35015    |   0.0 |  0.31
Other   |            | 0.05901    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.886496071719, Press = -0.0112581850531607
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -13474.152   -13474.152    -13546.88    -13546.88    281.46552    281.46552     31283.34     31283.34    1595.1794    1595.1794 
   84000   -13478.376   -13478.376   -13549.212   -13549.212    274.14051    274.14051    31281.982    31281.982    1275.0415    1275.0415 
Loop time of 117.408 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.736 ns/day, 32.613 hours/ns, 8.517 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.88     | 116.88     | 116.88     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098458   | 0.098458   | 0.098458   |   0.0 |  0.08
Output  | 0.00015635 | 0.00015635 | 0.00015635 |   0.0 |  0.00
Modify  | 0.36955    | 0.36955    | 0.36955    |   0.0 |  0.31
Other   |            | 0.06038    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.909845148795, Press = 0.20841211452764
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -13478.376   -13478.376   -13549.212   -13549.212    274.14051    274.14051    31281.982    31281.982    1275.0415    1275.0415 
   85000   -13478.901   -13478.901   -13548.567   -13548.567     269.6157     269.6157    31277.331    31277.331    1816.2903    1816.2903 
Loop time of 125.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.690 ns/day, 34.784 hours/ns, 7.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    | 124.65     | 124.65     | 124.65     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10473    | 0.10473    | 0.10473    |   0.0 |  0.08
Output  | 0.00025267 | 0.00025267 | 0.00025267 |   0.0 |  0.00
Modify  | 0.40462    | 0.40462    | 0.40462    |   0.0 |  0.32
Other   |            | 0.0629     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928645977593, Press = 0.327853912645193
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -13478.901   -13478.901   -13548.567   -13548.567     269.6157     269.6157    31277.331    31277.331    1816.2903    1816.2903 
   86000   -13479.823   -13479.823   -13548.264   -13548.264    264.87459    264.87459    31270.985    31270.985    2375.1398    2375.1398 
Loop time of 128.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.769 hours/ns, 7.766 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    | 128.18     | 128.18     | 128.18     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10671    | 0.10671    | 0.10671    |   0.0 |  0.08
Output  | 0.000195   | 0.000195   | 0.000195   |   0.0 |  0.00
Modify  | 0.42024    | 0.42024    | 0.42024    |   0.0 |  0.33
Other   |            | 0.06525    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.923912761441, Press = 0.834218936004642
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -13479.823   -13479.823   -13548.264   -13548.264    264.87459    264.87459    31270.985    31270.985    2375.1398    2375.1398 
   87000   -13475.133   -13475.133   -13547.182   -13547.182    278.83853    278.83853    31300.661    31300.661    292.20379    292.20379 
Loop time of 123.662 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.351 hours/ns, 8.087 timesteps/s
100.0% 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.09     | 123.09     | 123.09     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10379    | 0.10379    | 0.10379    |   0.0 |  0.08
Output  | 0.00018226 | 0.00018226 | 0.00018226 |   0.0 |  0.00
Modify  | 0.40122    | 0.40122    | 0.40122    |   0.0 |  0.32
Other   |            | 0.06371    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.912646751039, Press = 0.40994159920363
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -13475.133   -13475.133   -13547.182   -13547.182    278.83853    278.83853    31300.661    31300.661    292.20379    292.20379 
   88000    -13480.81    -13480.81   -13550.662   -13550.662     270.3361     270.3361    31307.452    31307.452   -1008.3154   -1008.3154 
Loop time of 118.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.728 ns/day, 32.948 hours/ns, 8.431 timesteps/s
100.0% 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.08     | 118.08     | 118.08     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098708   | 0.098708   | 0.098708   |   0.0 |  0.08
Output  | 0.00015584 | 0.00015584 | 0.00015584 |   0.0 |  0.00
Modify  | 0.37608    | 0.37608    | 0.37608    |   0.0 |  0.32
Other   |            | 0.06255    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.888027254616, Press = 0.0715308508644977
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000    -13480.81    -13480.81   -13550.662   -13550.662     270.3361     270.3361    31307.452    31307.452   -1008.3154   -1008.3154 
   89000   -13476.126   -13476.126   -13547.826   -13547.826    277.48395    277.48395     31323.77     31323.77   -1923.2191   -1923.2191 
Loop time of 131.752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.598 hours/ns, 7.590 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    | 131.14     | 131.14     | 131.14     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10976    | 0.10976    | 0.10976    |   0.0 |  0.08
Output  | 0.00026312 | 0.00026312 | 0.00026312 |   0.0 |  0.00
Modify  | 0.43426    | 0.43426    | 0.43426    |   0.0 |  0.33
Other   |            | 0.06686    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.885649322857, Press = 0.0321299066617429
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -13476.126   -13476.126   -13547.826   -13547.826    277.48395    277.48395     31323.77     31323.77   -1923.2191   -1923.2191 
   90000   -13479.866   -13479.866   -13548.679   -13548.679    266.31013    266.31013    31334.177    31334.177   -2945.9904   -2945.9904 
Loop time of 131.699 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.583 hours/ns, 7.593 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    | 131.09     | 131.09     | 131.09     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10869    | 0.10869    | 0.10869    |   0.0 |  0.08
Output  | 0.00015925 | 0.00015925 | 0.00015925 |   0.0 |  0.00
Modify  | 0.4385     | 0.4385     | 0.4385     |   0.0 |  0.33
Other   |            | 0.06653    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.867533347193, Press = -0.124048833126582
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -13479.866   -13479.866   -13548.679   -13548.679    266.31013    266.31013    31334.177    31334.177   -2945.9904   -2945.9904 
   91000   -13476.562   -13476.562   -13547.264   -13547.264    273.62614    273.62614    31361.395    31361.395   -5043.7151   -5043.7151 
Loop time of 130.997 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.388 hours/ns, 7.634 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.38     | 130.38     | 130.38     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10928    | 0.10928    | 0.10928    |   0.0 |  0.08
Output  | 0.00019504 | 0.00019504 | 0.00019504 |   0.0 |  0.00
Modify  | 0.43865    | 0.43865    | 0.43865    |   0.0 |  0.33
Other   |            | 0.06624    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845418452881, Press = -0.438820633387069
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -13476.562   -13476.562   -13547.264   -13547.264    273.62614    273.62614    31361.395    31361.395   -5043.7151   -5043.7151 
   92000   -13478.766   -13478.766   -13546.678   -13546.678    262.82647    262.82647    31326.516    31326.516   -2230.3501   -2230.3501 
Loop time of 131.691 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.581 hours/ns, 7.594 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.08     | 131.08     | 131.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10829    | 0.10829    | 0.10829    |   0.0 |  0.08
Output  | 0.00015695 | 0.00015695 | 0.00015695 |   0.0 |  0.00
Modify  | 0.43597    | 0.43597    | 0.43597    |   0.0 |  0.33
Other   |            | 0.06583    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.851570483011, Press = -0.456831333861438
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -13478.766   -13478.766   -13546.678   -13546.678    262.82647    262.82647    31326.516    31326.516   -2230.3501   -2230.3501 
   93000   -13476.289   -13476.289   -13547.235   -13547.235    274.56688    274.56688    31308.288    31308.288    -619.0789    -619.0789 
Loop time of 131.156 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.432 hours/ns, 7.625 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.55     | 130.55     | 130.55     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10848    | 0.10848    | 0.10848    |   0.0 |  0.08
Output  | 0.00020842 | 0.00020842 | 0.00020842 |   0.0 |  0.00
Modify  | 0.43466    | 0.43466    | 0.43466    |   0.0 |  0.33
Other   |            | 0.06583    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.880400140387, Press = -0.213835460950129
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -13476.289   -13476.289   -13547.235   -13547.235    274.56688    274.56688    31308.288    31308.288    -619.0789    -619.0789 
   94000   -13477.123   -13477.123   -13547.125   -13547.125    270.91185    270.91185    31300.733    31300.733    112.48923    112.48923 
Loop time of 121.493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.748 hours/ns, 8.231 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    | 120.94     | 120.94     | 120.94     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10109    | 0.10109    | 0.10109    |   0.0 |  0.08
Output  | 0.00015682 | 0.00015682 | 0.00015682 |   0.0 |  0.00
Modify  | 0.38913    | 0.38913    | 0.38913    |   0.0 |  0.32
Other   |            | 0.06253    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.885404258987, Press = -0.240204823304921
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -13477.123   -13477.123   -13547.125   -13547.125    270.91185    270.91185    31300.733    31300.733    112.48923    112.48923 
   95000   -13481.659   -13481.659   -13549.725   -13549.725    263.42335    263.42335    31284.176    31284.176    1077.9419    1077.9419 
Loop time of 132.071 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.686 hours/ns, 7.572 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.46     | 131.46     | 131.46     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10865    | 0.10865    | 0.10865    |   0.0 |  0.08
Output  | 0.00019629 | 0.00019629 | 0.00019629 |   0.0 |  0.00
Modify  | 0.43589    | 0.43589    | 0.43589    |   0.0 |  0.33
Other   |            | 0.06708    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869744697923, Press = -0.251860086755471
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -13481.659   -13481.659   -13549.725   -13549.725    263.42335    263.42335    31284.176    31284.176    1077.9419    1077.9419 
   96000   -13476.564   -13476.564   -13545.563   -13545.563     267.0308     267.0308    31265.822    31265.822    3220.7758    3220.7758 
Loop time of 125.583 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.884 hours/ns, 7.963 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    | 125.01     | 125.01     | 125.01     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10376    | 0.10376    | 0.10376    |   0.0 |  0.08
Output  | 0.00015371 | 0.00015371 | 0.00015371 |   0.0 |  0.00
Modify  | 0.40522    | 0.40522    | 0.40522    |   0.0 |  0.32
Other   |            | 0.0637     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.858411139773, Press = -0.155020331738912
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -13476.564   -13476.564   -13545.563   -13545.563     267.0308     267.0308    31265.822    31265.822    3220.7758    3220.7758 
   97000   -13479.945   -13479.945   -13548.753   -13548.753    266.29349    266.29349     31257.17     31257.17    3713.1413    3713.1413 
Loop time of 114.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.779 hours/ns, 8.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    | 113.89     | 113.89     | 113.89     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097942   | 0.097942   | 0.097942   |   0.0 |  0.09
Output  | 0.0001584  | 0.0001584  | 0.0001584  |   0.0 |  0.00
Modify  | 0.35787    | 0.35787    | 0.35787    |   0.0 |  0.31
Other   |            | 0.05956    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.84249684431, Press = 0.175834495171699
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -13479.945   -13479.945   -13548.753   -13548.753    266.29349    266.29349     31257.17     31257.17    3713.1413    3713.1413 
   98000   -13476.601   -13476.601   -13547.088   -13547.088     272.7903     272.7903    31275.844    31275.844    2272.2768    2272.2768 
Loop time of 128.156 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.599 hours/ns, 7.803 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    | 127.56     | 127.56     | 127.56     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10621    | 0.10621    | 0.10621    |   0.0 |  0.08
Output  | 0.00020635 | 0.00020635 | 0.00020635 |   0.0 |  0.00
Modify  | 0.42111    | 0.42111    | 0.42111    |   0.0 |  0.33
Other   |            | 0.06518    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.84130923456, Press = 0.264946314261148
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -13476.601   -13476.601   -13547.088   -13547.088     272.7903     272.7903    31275.844    31275.844    2272.2768    2272.2768 
   99000   -13478.472   -13478.472   -13548.888   -13548.888    272.52004    272.52004    31283.774    31283.774     1294.512     1294.512 
Loop time of 128.428 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.673 ns/day, 35.674 hours/ns, 7.786 timesteps/s
100.0% 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.83     | 127.83     | 127.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10619    | 0.10619    | 0.10619    |   0.0 |  0.08
Output  | 0.00022049 | 0.00022049 | 0.00022049 |   0.0 |  0.00
Modify  | 0.42356    | 0.42356    | 0.42356    |   0.0 |  0.33
Other   |            | 0.06572    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.847749329746, Press = 0.12639397920577
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -13478.472   -13478.472   -13548.888   -13548.888    272.52004    272.52004    31283.774    31283.774     1294.512     1294.512 
  100000   -13478.037   -13478.037   -13548.717   -13548.717       273.54       273.54    31291.991    31291.991    584.91463    584.91463 
Loop time of 131.683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.579 hours/ns, 7.594 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    | 131.07     | 131.07     | 131.07     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10876    | 0.10876    | 0.10876    |   0.0 |  0.08
Output  | 0.00015447 | 0.00015447 | 0.00015447 |   0.0 |  0.00
Modify  | 0.4328     | 0.4328     | 0.4328     |   0.0 |  0.33
Other   |            | 0.06624    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.855102867092, Press = 0.0720442584881425
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -13478.037   -13478.037   -13548.717   -13548.717       273.54       273.54    31291.991    31291.991    584.91463    584.91463 
  101000   -13481.358   -13481.358   -13551.051   -13551.051    269.71921    269.71921    31292.696    31292.696    214.35154    214.35154 
Loop time of 125.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.862 hours/ns, 7.968 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.93     | 124.93     | 124.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10406    | 0.10406    | 0.10406    |   0.0 |  0.08
Output  | 0.00020506 | 0.00020506 | 0.00020506 |   0.0 |  0.00
Modify  | 0.40481    | 0.40481    | 0.40481    |   0.0 |  0.32
Other   |            | 0.06395    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.856292585873, Press = -0.0401676001102631
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -13481.358   -13481.358   -13551.051   -13551.051    269.71921    269.71921    31292.696    31292.696    214.35154    214.35154 
  102000    -13476.92    -13476.92   -13545.896   -13545.896    266.94279    266.94279    31295.964    31295.964    709.28727    709.28727 
Loop time of 132.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.777 hours/ns, 7.553 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.78     | 131.78     | 131.78     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10949    | 0.10949    | 0.10949    |   0.0 |  0.08
Output  | 0.00018922 | 0.00018922 | 0.00018922 |   0.0 |  0.00
Modify  | 0.43917    | 0.43917    | 0.43917    |   0.0 |  0.33
Other   |            | 0.06617    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.833576061784, Press = -0.0576726449755553
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000    -13476.92    -13476.92   -13545.896   -13545.896    266.94279    266.94279    31295.964    31295.964    709.28727    709.28727 
  103000   -13481.253   -13481.253   -13550.213   -13550.213    266.88185    266.88185     31288.08     31288.08     684.8864     684.8864 
Loop time of 132.231 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.731 hours/ns, 7.563 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.62     | 131.62     | 131.62     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1084     | 0.1084     | 0.1084     |   0.0 |  0.08
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.43458    | 0.43458    | 0.43458    |   0.0 |  0.33
Other   |            | 0.06594    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.818378666355, Press = -0.174174723140773
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -13481.253   -13481.253   -13550.213   -13550.213    266.88185    266.88185     31288.08     31288.08     684.8864     684.8864 
  104000   -13476.758   -13476.758   -13548.794   -13548.794    278.78809    278.78809    31266.008    31266.008     2774.016     2774.016 
Loop time of 115.642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.123 hours/ns, 8.647 timesteps/s
100.0% 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.12     | 115.12     | 115.12     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097633   | 0.097633   | 0.097633   |   0.0 |  0.08
Output  | 0.0001904  | 0.0001904  | 0.0001904  |   0.0 |  0.00
Modify  | 0.36142    | 0.36142    | 0.36142    |   0.0 |  0.31
Other   |            | 0.05934    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.805185633537, Press = -0.242030014713737
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -13476.758   -13476.758   -13548.794   -13548.794    278.78809    278.78809    31266.008    31266.008     2774.016     2774.016 
  105000   -13480.733   -13480.733   -13550.393   -13550.393    269.59268    269.59268    31250.394    31250.394    3685.9902    3685.9902 
Loop time of 113.363 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.490 hours/ns, 8.821 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.86     | 112.86     | 112.86     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095777   | 0.095777   | 0.095777   |   0.0 |  0.08
Output  | 0.00015678 | 0.00015678 | 0.00015678 |   0.0 |  0.00
Modify  | 0.35013    | 0.35013    | 0.35013    |   0.0 |  0.31
Other   |            | 0.05797    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.783661284159, Press = 0.0764741434498035
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -13480.733   -13480.733   -13550.393   -13550.393    269.59268    269.59268    31250.394    31250.394    3685.9902    3685.9902 
  106000   -13477.898   -13477.898   -13547.577   -13547.577    269.66265    269.66265    31272.126    31272.126    2381.5776    2381.5776 
Loop time of 113.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.481 hours/ns, 8.824 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.83     | 112.83     | 112.83     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097885   | 0.097885   | 0.097885   |   0.0 |  0.09
Output  | 0.0001956  | 0.0001956  | 0.0001956  |   0.0 |  0.00
Modify  | 0.34907    | 0.34907    | 0.34907    |   0.0 |  0.31
Other   |            | 0.05817    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.77462750319, Press = 0.25912602309162
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000   -13477.898   -13477.898   -13547.577   -13547.577    269.66265    269.66265    31272.126    31272.126    2381.5776    2381.5776 
  107000   -13474.952   -13474.952   -13544.532   -13544.532    269.28213    269.28213     31290.54     31290.54    1276.3759    1276.3759 
Loop time of 113.36 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.489 hours/ns, 8.821 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.85     | 112.85     | 112.85     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098165   | 0.098165   | 0.098165   |   0.0 |  0.09
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.35118    | 0.35118    | 0.35118    |   0.0 |  0.31
Other   |            | 0.05812    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.786049091236, Press = 0.279211718232058
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -13474.952   -13474.952   -13544.532   -13544.532    269.28213    269.28213     31290.54     31290.54    1276.3759    1276.3759 
  108000   -13477.739   -13477.739   -13545.346   -13545.346    261.64552    261.64552    31298.184    31298.184    382.23497    382.23497 
Loop time of 113.446 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.513 hours/ns, 8.815 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.94     | 112.94     | 112.94     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098422   | 0.098422   | 0.098422   |   0.0 |  0.09
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.35133    | 0.35133    | 0.35133    |   0.0 |  0.31
Other   |            | 0.05823    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.789497523632, Press = 0.20857878514001
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -13477.739   -13477.739   -13545.346   -13545.346    261.64552    261.64552    31298.184    31298.184    382.23497    382.23497 
  109000   -13475.364   -13475.364   -13545.464   -13545.464    271.29454    271.29454    31306.148    31306.148   -56.080365   -56.080365 
Loop time of 113.548 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.541 hours/ns, 8.807 timesteps/s
100.0% 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.04     | 113.04     | 113.04     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099051   | 0.099051   | 0.099051   |   0.0 |  0.09
Output  | 0.00019527 | 0.00019527 | 0.00019527 |   0.0 |  0.00
Modify  | 0.353      | 0.353      | 0.353      |   0.0 |  0.31
Other   |            | 0.05784    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.817297577476, Press = 0.0467289670387872
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -13475.364   -13475.364   -13545.464   -13545.464    271.29454    271.29454    31306.148    31306.148   -56.080365   -56.080365 
  110000   -13479.607   -13479.607   -13549.322   -13549.322    269.80674    269.80674    31302.797    31302.797   -289.95996   -289.95996 
Loop time of 114.635 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.843 hours/ns, 8.723 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.12     | 114.12     | 114.12     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096505   | 0.096505   | 0.096505   |   0.0 |  0.08
Output  | 0.00015804 | 0.00015804 | 0.00015804 |   0.0 |  0.00
Modify  | 0.3558     | 0.3558     | 0.3558     |   0.0 |  0.31
Other   |            | 0.05919    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.814499724443, Press = -0.0879312809948695
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -13479.607   -13479.607   -13549.322   -13549.322    269.80674    269.80674    31302.797    31302.797   -289.95996   -289.95996 
  111000   -13476.377   -13476.377   -13547.471   -13547.471    275.14316    275.14316    31302.014    31302.014   -47.730826   -47.730826 
Loop time of 120.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.465 hours/ns, 8.301 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    | 119.93     | 119.93     | 119.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10097    | 0.10097    | 0.10097    |   0.0 |  0.08
Output  | 0.00019208 | 0.00019208 | 0.00019208 |   0.0 |  0.00
Modify  | 0.38604    | 0.38604    | 0.38604    |   0.0 |  0.32
Other   |            | 0.06179    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.810598859561, Press = -0.139154912453848
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -13476.377   -13476.377   -13547.471   -13547.471    275.14316    275.14316    31302.014    31302.014   -47.730826   -47.730826 
  112000   -13478.195   -13478.195   -13549.316   -13549.316    275.24395    275.24395    31302.282    31302.282   -312.49501   -312.49501 
Loop time of 119.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.247 hours/ns, 8.355 timesteps/s
100.0% 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.15     | 119.15     | 119.15     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10035    | 0.10035    | 0.10035    |   0.0 |  0.08
Output  | 0.00020482 | 0.00020482 | 0.00020482 |   0.0 |  0.00
Modify  | 0.37715    | 0.37715    | 0.37715    |   0.0 |  0.32
Other   |            | 0.06079    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.784666820684, Press = -0.132226435903645
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -13478.195   -13478.195   -13549.316   -13549.316    275.24395    275.24395    31302.282    31302.282   -312.49501   -312.49501 
  113000   -13476.121   -13476.121   -13545.956   -13545.956    270.27097    270.27097    31299.689    31299.689    344.59999    344.59999 
Loop time of 121.519 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.755 hours/ns, 8.229 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    | 120.97     | 120.97     | 120.97     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10271    | 0.10271    | 0.10271    |   0.0 |  0.08
Output  | 0.0001563  | 0.0001563  | 0.0001563  |   0.0 |  0.00
Modify  | 0.38408    | 0.38408    | 0.38408    |   0.0 |  0.32
Other   |            | 0.06174    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.788638854071, Press = -0.279180855852602
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -13476.121   -13476.121   -13545.956   -13545.956    270.27097    270.27097    31299.689    31299.689    344.59999    344.59999 
  114000   -13477.517   -13477.517   -13548.927   -13548.927    276.36389    276.36389    31300.141    31300.141    13.165795    13.165795 
Loop time of 120.414 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.718 ns/day, 33.448 hours/ns, 8.305 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    | 119.87     | 119.87     | 119.87     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10039    | 0.10039    | 0.10039    |   0.0 |  0.08
Output  | 0.00018959 | 0.00018959 | 0.00018959 |   0.0 |  0.00
Modify  | 0.38227    | 0.38227    | 0.38227    |   0.0 |  0.32
Other   |            | 0.06183    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.802105325025, Press = -0.452944512043594
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000   -13477.517   -13477.517   -13548.927   -13548.927    276.36389    276.36389    31300.141    31300.141    13.165795    13.165795 
  115000   -13476.646   -13476.646   -13548.803   -13548.803    279.25398    279.25398    31285.045    31285.045    1275.6703    1275.6703 
Loop time of 123.442 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.289 hours/ns, 8.101 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    | 122.88     | 122.88     | 122.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10367    | 0.10367    | 0.10367    |   0.0 |  0.08
Output  | 0.00018722 | 0.00018722 | 0.00018722 |   0.0 |  0.00
Modify  | 0.39718    | 0.39718    | 0.39718    |   0.0 |  0.32
Other   |            | 0.06316    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8319741551, Press = -0.623479225210439
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -13476.646   -13476.646   -13548.803   -13548.803    279.25398    279.25398    31285.045    31285.045    1275.6703    1275.6703 
  116000   -13478.414   -13478.414   -13547.645   -13547.645    267.92866    267.92866    31271.595    31271.595     2465.391     2465.391 
Loop time of 115.741 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.746 ns/day, 32.150 hours/ns, 8.640 timesteps/s
100.0% 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.22     | 115.22     | 115.22     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097667   | 0.097667   | 0.097667   |   0.0 |  0.08
Output  | 0.00015635 | 0.00015635 | 0.00015635 |   0.0 |  0.00
Modify  | 0.36074    | 0.36074    | 0.36074    |   0.0 |  0.31
Other   |            | 0.06082    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.83210136629, Press = -0.49742798272514
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -13478.414   -13478.414   -13547.645   -13547.645    267.92866    267.92866    31271.595    31271.595     2465.391     2465.391 
  117000   -13477.361   -13477.361   -13548.397   -13548.397    274.91732    274.91732    31284.996    31284.996    1240.9357    1240.9357 
Loop time of 120.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.718 ns/day, 33.431 hours/ns, 8.309 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    | 119.81     | 119.81     | 119.81     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10104    | 0.10104    | 0.10104    |   0.0 |  0.08
Output  | 0.00015663 | 0.00015663 | 0.00015663 |   0.0 |  0.00
Modify  | 0.38105    | 0.38105    | 0.38105    |   0.0 |  0.32
Other   |            | 0.06232    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.836077477649, Press = -0.211160819032581
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -13477.361   -13477.361   -13548.397   -13548.397    274.91732    274.91732    31284.996    31284.996    1240.9357    1240.9357 
  118000   -13477.118   -13477.118   -13549.102   -13549.102    278.58548    278.58548    31290.916    31290.916    744.56014    744.56014 
Loop time of 131.539 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.657 ns/day, 36.539 hours/ns, 7.602 timesteps/s
100.0% 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.93     | 130.93     | 130.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10964    | 0.10964    | 0.10964    |   0.0 |  0.08
Output  | 0.00018883 | 0.00018883 | 0.00018883 |   0.0 |  0.00
Modify  | 0.43212    | 0.43212    | 0.43212    |   0.0 |  0.33
Other   |            | 0.06538    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.830972496092, Press = -0.0171454795611764
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -13477.118   -13477.118   -13549.102   -13549.102    278.58548    278.58548    31290.916    31290.916    744.56014    744.56014 
  119000     -13477.8     -13477.8   -13546.929   -13546.929    267.53537    267.53537    31283.852    31283.852    1520.2784    1520.2784 
Loop time of 125.254 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.690 ns/day, 34.793 hours/ns, 7.984 timesteps/s
100.0% 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.68     | 124.68     | 124.68     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10572    | 0.10572    | 0.10572    |   0.0 |  0.08
Output  | 0.00021863 | 0.00021863 | 0.00021863 |   0.0 |  0.00
Modify  | 0.40659    | 0.40659    | 0.40659    |   0.0 |  0.32
Other   |            | 0.06383    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.840484578224, Press = 0.0797941873702132
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000     -13477.8     -13477.8   -13546.929   -13546.929    267.53537    267.53537    31283.852    31283.852    1520.2784    1520.2784 
  120000   -13475.706   -13475.706   -13544.326   -13544.326    265.56632    265.56632    31285.414    31285.414    1889.2539    1889.2539 
Loop time of 118.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 32.994 hours/ns, 8.419 timesteps/s
100.0% 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.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10116    | 0.10116    | 0.10116    |   0.0 |  0.09
Output  | 0.00015959 | 0.00015959 | 0.00015959 |   0.0 |  0.00
Modify  | 0.3764     | 0.3764     | 0.3764     |   0.0 |  0.32
Other   |            | 0.06119    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.854489355315, Press = 0.352128288536484
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -13475.706   -13475.706   -13544.326   -13544.326    265.56632    265.56632    31285.414    31285.414    1889.2539    1889.2539 
  121000   -13479.199   -13479.199   -13548.053   -13548.053    266.47186    266.47186    31297.483    31297.483    158.93883    158.93883 
Loop time of 118.501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.729 ns/day, 32.917 hours/ns, 8.439 timesteps/s
100.0% 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.96     | 117.96     | 117.96     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1008     | 0.1008     | 0.1008     |   0.0 |  0.09
Output  | 0.00015626 | 0.00015626 | 0.00015626 |   0.0 |  0.00
Modify  | 0.37727    | 0.37727    | 0.37727    |   0.0 |  0.32
Other   |            | 0.06102    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.875317292179, Press = 0.669723837955038
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000   -13479.199   -13479.199   -13548.053   -13548.053    266.47186    266.47186    31297.483    31297.483    158.93883    158.93883 
  122000   -13477.996   -13477.996   -13548.532   -13548.532    272.98136    272.98136    31318.043    31318.043   -1481.6393   -1481.6393 
Loop time of 124.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.692 ns/day, 34.667 hours/ns, 8.013 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.22     | 124.22     | 124.22     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10589    | 0.10589    | 0.10589    |   0.0 |  0.08
Output  | 0.00015831 | 0.00015831 | 0.00015831 |   0.0 |  0.00
Modify  | 0.40522    | 0.40522    | 0.40522    |   0.0 |  0.32
Other   |            | 0.06341    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.879714486542, Press = 0.211080150814368
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  122000   -13477.996   -13477.996   -13548.532   -13548.532    272.98136    272.98136    31318.043    31318.043   -1481.6393   -1481.6393 
  123000   -13477.763   -13477.763   -13548.703   -13548.703    274.54446    274.54446    31312.791    31312.791   -1147.6455   -1147.6455 
Loop time of 120.733 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.537 hours/ns, 8.283 timesteps/s
100.0% 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.18     | 120.18     | 120.18     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1019     | 0.1019     | 0.1019     |   0.0 |  0.08
Output  | 0.00016023 | 0.00016023 | 0.00016023 |   0.0 |  0.00
Modify  | 0.38434    | 0.38434    | 0.38434    |   0.0 |  0.32
Other   |            | 0.06204    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.857605915848, Press = 0.0175268209553549
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  123000   -13477.763   -13477.763   -13548.703   -13548.703    274.54446    274.54446    31312.791    31312.791   -1147.6455   -1147.6455 
  124000   -13478.755   -13478.755   -13549.971   -13549.971    275.61448    275.61448    31321.304    31321.304   -1957.4275   -1957.4275 
Loop time of 127.243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.345 hours/ns, 7.859 timesteps/s
100.0% 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.66     | 126.66     | 126.66     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10497    | 0.10497    | 0.10497    |   0.0 |  0.08
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.41325    | 0.41325    | 0.41325    |   0.0 |  0.32
Other   |            | 0.06414    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.848350564435, Press = -0.145095710462124
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  124000   -13478.755   -13478.755   -13549.971   -13549.971    275.61448    275.61448    31321.304    31321.304   -1957.4275   -1957.4275 
  125000   -13475.273   -13475.273   -13546.178   -13546.178    274.40915    274.40915    31326.079    31326.079   -1802.8748   -1802.8748 
Loop time of 132.035 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.676 hours/ns, 7.574 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.43     | 131.43     | 131.43     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10827    | 0.10827    | 0.10827    |   0.0 |  0.08
Output  | 0.00018901 | 0.00018901 | 0.00018901 |   0.0 |  0.00
Modify  | 0.43427    | 0.43427    | 0.43427    |   0.0 |  0.33
Other   |            | 0.06641    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.835372165965, Press = -0.243041689234479
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  125000   -13475.273   -13475.273   -13546.178   -13546.178    274.40915    274.40915    31326.079    31326.079   -1802.8748   -1802.8748 
  126000   -13477.007   -13477.007   -13548.935   -13548.935    278.36975    278.36975    31342.598    31342.598   -3706.9489   -3706.9489 
Loop time of 129.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 35.985 hours/ns, 7.719 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    | 128.95     | 128.95     | 128.95     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10676    | 0.10676    | 0.10676    |   0.0 |  0.08
Output  | 0.0002708  | 0.0002708  | 0.0002708  |   0.0 |  0.00
Modify  | 0.42265    | 0.42265    | 0.42265    |   0.0 |  0.33
Other   |            | 0.0654     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.839048857348, Press = -0.685947039063754
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  126000   -13477.007   -13477.007   -13548.935   -13548.935    278.36975    278.36975    31342.598    31342.598   -3706.9489   -3706.9489 
  127000   -13477.283   -13477.283   -13548.841   -13548.841    276.93907    276.93907    31311.813    31311.813   -977.17011   -977.17011 
Loop time of 132.086 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.691 hours/ns, 7.571 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.48     | 131.48     | 131.48     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10859    | 0.10859    | 0.10859    |   0.0 |  0.08
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.43425    | 0.43425    | 0.43425    |   0.0 |  0.33
Other   |            | 0.06674    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.859747743181, Press = -0.521103529208757
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  127000   -13477.283   -13477.283   -13548.841   -13548.841    276.93907    276.93907    31311.813    31311.813   -977.17011   -977.17011 
  128000    -13478.98    -13478.98   -13548.229   -13548.229    268.00031    268.00031    31294.036    31294.036    398.72806    398.72806 
Loop time of 131.691 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.581 hours/ns, 7.594 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.08     | 131.08     | 131.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1073     | 0.1073     | 0.1073     |   0.0 |  0.08
Output  | 0.0001954  | 0.0001954  | 0.0001954  |   0.0 |  0.00
Modify  | 0.43304    | 0.43304    | 0.43304    |   0.0 |  0.33
Other   |            | 0.06607    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.876055093886, Press = -0.186882316157037
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  128000    -13478.98    -13478.98   -13548.229   -13548.229    268.00031    268.00031    31294.036    31294.036    398.72806    398.72806 
  129000   -13474.895   -13474.895   -13547.154   -13547.154    279.65045    279.65045    31294.811    31294.811    595.65494    595.65494 
Loop time of 120.663 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.517 hours/ns, 8.288 timesteps/s
100.0% 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.12     | 120.12     | 120.12     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10136    | 0.10136    | 0.10136    |   0.0 |  0.08
Output  | 0.00015797 | 0.00015797 | 0.00015797 |   0.0 |  0.00
Modify  | 0.38373    | 0.38373    | 0.38373    |   0.0 |  0.32
Other   |            | 0.06185    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.896406541088, Press = -0.0921612927466741
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  129000   -13474.895   -13474.895   -13547.154   -13547.154    279.65045    279.65045    31294.811    31294.811    595.65494    595.65494 
  130000   -13474.731   -13474.731   -13547.166   -13547.166    280.33106    280.33106    31292.383    31292.383    973.83117    973.83117 
Loop time of 131.279 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.466 hours/ns, 7.617 timesteps/s
100.0% 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.67     | 130.67     | 130.67     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1086     | 0.1086     | 0.1086     |   0.0 |  0.08
Output  | 0.00015561 | 0.00015561 | 0.00015561 |   0.0 |  0.00
Modify  | 0.43537    | 0.43537    | 0.43537    |   0.0 |  0.33
Other   |            | 0.06663    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.900469884129, Press = -0.0488684755400252
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  130000   -13474.731   -13474.731   -13547.166   -13547.166    280.33106    280.33106    31292.383    31292.383    973.83117    973.83117 
  131000   -13478.008   -13478.008   -13547.926   -13547.926    270.59288    270.59288    31283.123    31283.123    1521.2834    1521.2834 
Loop time of 129.303 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.71     | 128.71     | 128.71     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10697    | 0.10697    | 0.10697    |   0.0 |  0.08
Output  | 0.00015965 | 0.00015965 | 0.00015965 |   0.0 |  0.00
Modify  | 0.42373    | 0.42373    | 0.42373    |   0.0 |  0.33
Other   |            | 0.06536    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.903202354164, Press = 0.125201879775732
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  131000   -13478.008   -13478.008   -13547.926   -13547.926    270.59288    270.59288    31283.123    31283.123    1521.2834    1521.2834 
  132000   -13476.795   -13476.795   -13547.565   -13547.565    273.88713    273.88713    31291.078    31291.078    841.31562    841.31562 
Loop time of 132.642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.845 hours/ns, 7.539 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    | 132.02     | 132.02     | 132.02     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1094     | 0.1094     | 0.1094     |   0.0 |  0.08
Output  | 0.0002029  | 0.0002029  | 0.0002029  |   0.0 |  0.00
Modify  | 0.44078    | 0.44078    | 0.44078    |   0.0 |  0.33
Other   |            | 0.06646    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.904868027596, Press = 0.328695533217731
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  132000   -13476.795   -13476.795   -13547.565   -13547.565    273.88713    273.88713    31291.078    31291.078    841.31562    841.31562 
  133000   -13480.573   -13480.573   -13547.755   -13547.755    260.00166    260.00166    31293.458    31293.458    650.55671    650.55671 
Loop time of 129.982 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.106 hours/ns, 7.693 timesteps/s
100.0% 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.37     | 129.37     | 129.37     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10893    | 0.10893    | 0.10893    |   0.0 |  0.08
Output  | 0.00024602 | 0.00024602 | 0.00024602 |   0.0 |  0.00
Modify  | 0.43849    | 0.43849    | 0.43849    |   0.0 |  0.34
Other   |            | 0.0661     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.888557121757, Press = 0.398396278102998
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  133000   -13480.573   -13480.573   -13547.755   -13547.755    260.00166    260.00166    31293.458    31293.458    650.55671    650.55671 
  134000   -13475.557   -13475.557   -13545.856   -13545.856    272.06236    272.06236    31306.298    31306.298   -54.539454   -54.539454 
Loop time of 132.168 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.713 hours/ns, 7.566 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    | 131.56     | 131.56     | 131.56     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10804    | 0.10804    | 0.10804    |   0.0 |  0.08
Output  | 0.00015769 | 0.00015769 | 0.00015769 |   0.0 |  0.00
Modify  | 0.43682    | 0.43682    | 0.43682    |   0.0 |  0.33
Other   |            | 0.06607    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.884309870993, Press = 0.267783275244017
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  134000   -13475.557   -13475.557   -13545.856   -13545.856    272.06236    272.06236    31306.298    31306.298   -54.539454   -54.539454 
  135000   -13478.617   -13478.617   -13547.903   -13547.903    268.14261    268.14261    31306.638    31306.638   -397.09697   -397.09697 
Loop time of 123.616 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.338 hours/ns, 8.090 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    | 123.05     | 123.05     | 123.05     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10407    | 0.10407    | 0.10407    |   0.0 |  0.08
Output  | 0.00019941 | 0.00019941 | 0.00019941 |   0.0 |  0.00
Modify  | 0.40008    | 0.40008    | 0.40008    |   0.0 |  0.32
Other   |            | 0.06401    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.870969579041, Press = 0.0751635538922738
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  135000   -13478.617   -13478.617   -13547.903   -13547.903    268.14261    268.14261    31306.638    31306.638   -397.09697   -397.09697 
  136000   -13475.751   -13475.751   -13546.938   -13546.938    275.50032    275.50032    31317.498    31317.498   -1102.5852   -1102.5852 
Loop time of 134.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.336 hours/ns, 7.440 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    | 133.79     | 133.79     | 133.79     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11087    | 0.11087    | 0.11087    |   0.0 |  0.08
Output  | 0.00015765 | 0.00015765 | 0.00015765 |   0.0 |  0.00
Modify  | 0.44625    | 0.44625    | 0.44625    |   0.0 |  0.33
Other   |            | 0.06682    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.864748308145, Press = -0.0127840173772447
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  136000   -13475.751   -13475.751   -13546.938   -13546.938    275.50032    275.50032    31317.498    31317.498   -1102.5852   -1102.5852 
  137000    -13480.04    -13480.04   -13550.129   -13550.129    271.25165    271.25165    31328.327    31328.327   -2530.3335   -2530.3335 
Loop time of 133.076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.966 hours/ns, 7.514 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    | 132.46     | 132.46     | 132.46     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10988    | 0.10988    | 0.10988    |   0.0 |  0.08
Output  | 0.00020043 | 0.00020043 | 0.00020043 |   0.0 |  0.00
Modify  | 0.44199    | 0.44199    | 0.44199    |   0.0 |  0.33
Other   |            | 0.06674    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.85331398601, Press = -0.105097589770627
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  137000    -13480.04    -13480.04   -13550.129   -13550.129    271.25165    271.25165    31328.327    31328.327   -2530.3335   -2530.3335 
  138000   -13476.719   -13476.719     -13546.9     -13546.9    271.60942    271.60942    31340.209    31340.209   -3118.7694   -3118.7694 
Loop time of 132.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.790 hours/ns, 7.550 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    | 131.83     | 131.83     | 131.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10921    | 0.10921    | 0.10921    |   0.0 |  0.08
Output  | 0.00015613 | 0.00015613 | 0.00015613 |   0.0 |  0.00
Modify  | 0.43729    | 0.43729    | 0.43729    |   0.0 |  0.33
Other   |            | 0.06596    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.850271445408, Press = -0.346191899190823
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  138000   -13476.719   -13476.719     -13546.9     -13546.9    271.60942    271.60942    31340.209    31340.209   -3118.7694   -3118.7694 
  139000   -13478.288   -13478.288   -13547.248   -13547.248    266.88011    266.88011    31322.001    31322.001   -1796.2355   -1796.2355 
Loop time of 124.851 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.692 ns/day, 34.681 hours/ns, 8.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    | 124.28     | 124.28     | 124.28     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10435    | 0.10435    | 0.10435    |   0.0 |  0.08
Output  | 0.00018946 | 0.00018946 | 0.00018946 |   0.0 |  0.00
Modify  | 0.40441    | 0.40441    | 0.40441    |   0.0 |  0.32
Other   |            | 0.06449    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.84926688615, Press = -0.397966664449842
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  139000   -13478.288   -13478.288   -13547.248   -13547.248    266.88011    266.88011    31322.001    31322.001   -1796.2355   -1796.2355 
  140000   -13474.914   -13474.914   -13547.799   -13547.799    282.07248    282.07248     31310.38     31310.38   -725.52682   -725.52682 
Loop time of 118.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.729 ns/day, 32.928 hours/ns, 8.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    | 118        | 118        | 118        |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099479   | 0.099479   | 0.099479   |   0.0 |  0.08
Output  | 0.00015422 | 0.00015422 | 0.00015422 |   0.0 |  0.00
Modify  | 0.37451    | 0.37451    | 0.37451    |   0.0 |  0.32
Other   |            | 0.06143    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.85443886638, Press = -0.18213620728658
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  140000   -13474.914   -13474.914   -13547.799   -13547.799    282.07248    282.07248     31310.38     31310.38   -725.52682   -725.52682 
  141000    -13478.24    -13478.24   -13548.857   -13548.857    273.29726    273.29726    31301.858    31301.858   -238.22844   -238.22844 
Loop time of 123.189 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.219 hours/ns, 8.118 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    | 122.63     | 122.63     | 122.63     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10182    | 0.10182    | 0.10182    |   0.0 |  0.08
Output  | 0.0001562  | 0.0001562  | 0.0001562  |   0.0 |  0.00
Modify  | 0.39559    | 0.39559    | 0.39559    |   0.0 |  0.32
Other   |            | 0.06367    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.865287221159, Press = -0.186495197267702
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  141000    -13478.24    -13478.24   -13548.857   -13548.857    273.29726    273.29726    31301.858    31301.858   -238.22844   -238.22844 
  142000   -13474.725   -13474.725   -13545.496   -13545.496    273.88911    273.88911    31309.007    31309.007   -310.69181   -310.69181 
Loop time of 132.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.702 hours/ns, 7.568 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    | 131.51     | 131.51     | 131.51     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10842    | 0.10842    | 0.10842    |   0.0 |  0.08
Output  | 0.00015847 | 0.00015847 | 0.00015847 |   0.0 |  0.00
Modify  | 0.43997    | 0.43997    | 0.43997    |   0.0 |  0.33
Other   |            | 0.06823    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.874389715453, Press = -0.246847136584556
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  142000   -13474.725   -13474.725   -13545.496   -13545.496    273.88911    273.88911    31309.007    31309.007   -310.69181   -310.69181 
  143000   -13479.919   -13479.919   -13547.948   -13547.948    263.27882    263.27882    31322.322    31322.322   -1783.9705   -1783.9705 
Loop time of 121.825 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.840 hours/ns, 8.209 timesteps/s
100.0% 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.27     | 121.27     | 121.27     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10256    | 0.10256    | 0.10256    |   0.0 |  0.08
Output  | 0.00015438 | 0.00015438 | 0.00015438 |   0.0 |  0.00
Modify  | 0.39357    | 0.39357    | 0.39357    |   0.0 |  0.32
Other   |            | 0.06234    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.876745345445, Press = -0.417971887081125
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  143000   -13479.919   -13479.919   -13547.948   -13547.948    263.27882    263.27882    31322.322    31322.322   -1783.9705   -1783.9705 
  144000   -13477.022   -13477.022   -13546.281   -13546.281     268.0395     268.0395    31317.603    31317.603   -1234.7834   -1234.7834 
Loop time of 113.107 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.419 hours/ns, 8.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    | 112.6      | 112.6      | 112.6      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095143   | 0.095143   | 0.095143   |   0.0 |  0.08
Output  | 0.00015774 | 0.00015774 | 0.00015774 |   0.0 |  0.00
Modify  | 0.34908    | 0.34908    | 0.34908    |   0.0 |  0.31
Other   |            | 0.05923    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.860076494958, Press = -0.527530005307113
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  144000   -13477.022   -13477.022   -13546.281   -13546.281     268.0395     268.0395    31317.603    31317.603   -1234.7834   -1234.7834 
  145000   -13478.846   -13478.846   -13547.205   -13547.205    264.55465    264.55465    31303.831    31303.831   -307.01256   -307.01256 
Loop time of 120.509 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.475 hours/ns, 8.298 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    | 119.96     | 119.96     | 119.96     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1008     | 0.1008     | 0.1008     |   0.0 |  0.08
Output  | 0.00015816 | 0.00015816 | 0.00015816 |   0.0 |  0.00
Modify  | 0.38237    | 0.38237    | 0.38237    |   0.0 |  0.32
Other   |            | 0.06214    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.864268575614, Press = -0.388867361302696
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  145000   -13478.846   -13478.846   -13547.205   -13547.205    264.55465    264.55465    31303.831    31303.831   -307.01256   -307.01256 
  146000   -13475.519   -13475.519    -13548.24    -13548.24    281.43604    281.43604    31305.304    31305.304   -437.04785   -437.04785 
Loop time of 130.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.114 hours/ns, 7.692 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    | 129.4      | 129.4      | 129.4      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10976    | 0.10976    | 0.10976    |   0.0 |  0.08
Output  | 0.00015689 | 0.00015689 | 0.00015689 |   0.0 |  0.00
Modify  | 0.43594    | 0.43594    | 0.43594    |   0.0 |  0.34
Other   |            | 0.066      |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.878449816808, Press = -0.25119014207632
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  146000   -13475.519   -13475.519    -13548.24    -13548.24    281.43604    281.43604    31305.304    31305.304   -437.04785   -437.04785 
  147000    -13479.89    -13479.89   -13548.752   -13548.752    266.50511    266.50511    31303.187    31303.187   -371.28671   -371.28671 
Loop time of 127.398 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.388 hours/ns, 7.849 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.81     | 126.81     | 126.81     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10657    | 0.10657    | 0.10657    |   0.0 |  0.08
Output  | 0.00015464 | 0.00015464 | 0.00015464 |   0.0 |  0.00
Modify  | 0.42052    | 0.42052    | 0.42052    |   0.0 |  0.33
Other   |            | 0.06445    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.877220728256, Press = -0.179451908306187
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  147000    -13479.89    -13479.89   -13548.752   -13548.752    266.50511    266.50511    31303.187    31303.187   -371.28671   -371.28671 
  148000   -13478.872   -13478.872   -13548.135   -13548.135      268.055      268.055    31304.592    31304.592   -292.68047   -292.68047 
Loop time of 124.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.572 hours/ns, 8.035 timesteps/s
100.0% 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.89     | 123.89     | 123.89     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10305    | 0.10305    | 0.10305    |   0.0 |  0.08
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.39844    | 0.39844    | 0.39844    |   0.0 |  0.32
Other   |            | 0.06359    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.875200840412, Press = -0.165957831133632
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  148000   -13478.872   -13478.872   -13548.135   -13548.135      268.055      268.055    31304.592    31304.592   -292.68047   -292.68047 
  149000    -13476.83    -13476.83   -13549.571   -13549.571    281.51442    281.51442    31302.794    31302.794     -324.718     -324.718 
Loop time of 132.447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.791 hours/ns, 7.550 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.83     | 131.83     | 131.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10817    | 0.10817    | 0.10817    |   0.0 |  0.08
Output  | 0.00019772 | 0.00019772 | 0.00019772 |   0.0 |  0.00
Modify  | 0.43849    | 0.43849    | 0.43849    |   0.0 |  0.33
Other   |            | 0.06711    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.880026274405, Press = -0.211090306971924
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  149000    -13476.83    -13476.83   -13549.571   -13549.571    281.51442    281.51442    31302.794    31302.794     -324.718     -324.718 
  150000    -13475.67    -13475.67   -13548.582   -13548.582    282.17878    282.17878    31296.115    31296.115     434.5435     434.5435 
Loop time of 125.751 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.687 ns/day, 34.931 hours/ns, 7.952 timesteps/s
100.0% 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.17     | 125.17     | 125.17     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10509    | 0.10509    | 0.10509    |   0.0 |  0.08
Output  | 0.00015499 | 0.00015499 | 0.00015499 |   0.0 |  0.00
Modify  | 0.40742    | 0.40742    | 0.40742    |   0.0 |  0.32
Other   |            | 0.06469    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.878549791596, Press = -0.298366014710162
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  150000    -13475.67    -13475.67   -13548.582   -13548.582    282.17878    282.17878    31296.115    31296.115     434.5435     434.5435 
  151000   -13478.429   -13478.429   -13547.973   -13547.973    269.14413    269.14413    31260.249    31260.249    3351.0265    3351.0265 
Loop time of 118.25 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.847 hours/ns, 8.457 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.71     | 117.71     | 117.71     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098713   | 0.098713   | 0.098713   |   0.0 |  0.08
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.3743     | 0.3743     | 0.3743     |   0.0 |  0.32
Other   |            | 0.06283    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.884750785298, Press = -0.608885904569849
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  151000   -13478.429   -13478.429   -13547.973   -13547.973    269.14413    269.14413    31260.249    31260.249    3351.0265    3351.0265 
  152000   -13473.791   -13473.791   -13545.644   -13545.644    278.07896    278.07896    31266.983    31266.983    3135.8474    3135.8474 
Loop time of 131.089 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.414 hours/ns, 7.628 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.48     | 130.48     | 130.48     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10915    | 0.10915    | 0.10915    |   0.0 |  0.08
Output  | 0.00015456 | 0.00015456 | 0.00015456 |   0.0 |  0.00
Modify  | 0.43779    | 0.43779    | 0.43779    |   0.0 |  0.33
Other   |            | 0.06689    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.896880134309, Press = -0.254911808513199
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  152000   -13473.791   -13473.791   -13545.644   -13545.644    278.07896    278.07896    31266.983    31266.983    3135.8474    3135.8474 
  153000   -13479.062   -13479.062   -13548.341   -13548.341    268.11675    268.11675    31267.849    31267.849    2681.4035    2681.4035 
Loop time of 113.112 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.420 hours/ns, 8.841 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.61     | 112.61     | 112.61     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093814   | 0.093814   | 0.093814   |   0.0 |  0.08
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.34981    | 0.34981    | 0.34981    |   0.0 |  0.31
Other   |            | 0.06017    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.903873400651, Press = -0.0202548027339771
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  153000   -13479.062   -13479.062   -13548.341   -13548.341    268.11675    268.11675    31267.849    31267.849    2681.4035    2681.4035 
  154000   -13477.098   -13477.098   -13548.112   -13548.112    274.83245    274.83245    31272.981    31272.981    2338.2345    2338.2345 
Loop time of 124.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.522 hours/ns, 8.046 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    | 123.71     | 123.71     | 123.71     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10276    | 0.10276    | 0.10276    |   0.0 |  0.08
Output  | 0.00015582 | 0.00015582 | 0.00015582 |   0.0 |  0.00
Modify  | 0.40185    | 0.40185    | 0.40185    |   0.0 |  0.32
Other   |            | 0.06265    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.911363727312, Press = 0.057308286959433
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  154000   -13477.098   -13477.098   -13548.112   -13548.112    274.83245    274.83245    31272.981    31272.981    2338.2345    2338.2345 
  155000   -13478.376   -13478.376   -13548.785   -13548.785     272.4921     272.4921    31279.681    31279.681    1679.4169    1679.4169 
Loop time of 113.237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.455 hours/ns, 8.831 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.73     | 112.73     | 112.73     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095244   | 0.095244   | 0.095244   |   0.0 |  0.08
Output  | 0.00015705 | 0.00015705 | 0.00015705 |   0.0 |  0.00
Modify  | 0.34818    | 0.34818    | 0.34818    |   0.0 |  0.31
Other   |            | 0.05892    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.917625406602, Press = 0.146126933792273
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  155000   -13478.376   -13478.376   -13548.785   -13548.785     272.4921     272.4921    31279.681    31279.681    1679.4169    1679.4169 
  156000   -13477.642   -13477.642    -13547.81    -13547.81    271.55828    271.55828    31296.904    31296.904    213.04648    213.04648 
Loop time of 126.064 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.685 ns/day, 35.018 hours/ns, 7.932 timesteps/s
100.0% 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.49     | 125.49     | 125.49     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10374    | 0.10374    | 0.10374    |   0.0 |  0.08
Output  | 0.00055885 | 0.00055885 | 0.00055885 |   0.0 |  0.00
Modify  | 0.41027    | 0.41027    | 0.41027    |   0.0 |  0.33
Other   |            | 0.06377    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928106852287, Press = 0.0133178147822575
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  156000   -13477.642   -13477.642    -13547.81    -13547.81    271.55828    271.55828    31296.904    31296.904    213.04648    213.04648 
  157000     -13474.2     -13474.2   -13545.153   -13545.153    274.59561    274.59561    31305.811    31305.811   -77.375007   -77.375007 
Loop time of 125.912 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 34.976 hours/ns, 7.942 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    | 125.34     | 125.34     | 125.34     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10382    | 0.10382    | 0.10382    |   0.0 |  0.08
Output  | 0.00021209 | 0.00021209 | 0.00021209 |   0.0 |  0.00
Modify  | 0.4054     | 0.4054     | 0.4054     |   0.0 |  0.32
Other   |            | 0.06493    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928866856903, Press = -0.0269120987850206
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  157000     -13474.2     -13474.2   -13545.153   -13545.153    274.59561    274.59561    31305.811    31305.811   -77.375007   -77.375007 
  158000   -13477.667   -13477.667   -13548.412   -13548.412    273.78834    273.78834    31302.744    31302.744   -318.90516   -318.90516 
Loop time of 124.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.569 hours/ns, 8.035 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    | 123.88     | 123.88     | 123.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10329    | 0.10329    | 0.10329    |   0.0 |  0.08
Output  | 0.00019426 | 0.00019426 | 0.00019426 |   0.0 |  0.00
Modify  | 0.40104    | 0.40104    | 0.40104    |   0.0 |  0.32
Other   |            | 0.06313    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.932596400635, Press = -0.0706988470718072
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  158000   -13477.667   -13477.667   -13548.412   -13548.412    273.78834    273.78834    31302.744    31302.744   -318.90516   -318.90516 
  159000   -13475.448   -13475.448   -13547.301   -13547.301       278.08       278.08    31311.447    31311.447    -737.6089    -737.6089 
Loop time of 113.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.461 hours/ns, 8.829 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.75     | 112.75     | 112.75     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094721   | 0.094721   | 0.094721   |   0.0 |  0.08
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.35032    | 0.35032    | 0.35032    |   0.0 |  0.31
Other   |            | 0.0599     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.935642630995, Press = -0.0856111249303958
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  159000   -13475.448   -13475.448   -13547.301   -13547.301       278.08       278.08    31311.447    31311.447    -737.6089    -737.6089 
  160000   -13476.286   -13476.286    -13547.48    -13547.48    275.52776    275.52776    31316.772    31316.772   -1237.7691   -1237.7691 
Loop time of 125.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.889 hours/ns, 7.962 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    | 125.02     | 125.02     | 125.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10465    | 0.10465    | 0.10465    |   0.0 |  0.08
Output  | 0.00025344 | 0.00025344 | 0.00025344 |   0.0 |  0.00
Modify  | 0.40978    | 0.40978    | 0.40978    |   0.0 |  0.33
Other   |            | 0.06381    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.936692955538, Press = -0.135222334014052
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  160000   -13476.286   -13476.286    -13547.48    -13547.48    275.52776    275.52776    31316.772    31316.772   -1237.7691   -1237.7691 
  161000   -13479.297   -13479.297   -13549.353   -13549.353    271.12631    271.12631    31308.269    31308.269   -754.61827   -754.61827 
Loop time of 130.858 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.349 hours/ns, 7.642 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    | 130.25     | 130.25     | 130.25     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10888    | 0.10888    | 0.10888    |   0.0 |  0.08
Output  | 0.00019944 | 0.00019944 | 0.00019944 |   0.0 |  0.00
Modify  | 0.43681    | 0.43681    | 0.43681    |   0.0 |  0.33
Other   |            | 0.06548    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928066101615, Press = -0.289610013041966
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  161000   -13479.297   -13479.297   -13549.353   -13549.353    271.12631    271.12631    31308.269    31308.269   -754.61827   -754.61827 
  162000   -13476.577   -13476.577   -13548.206   -13548.206    277.21196    277.21196    31293.583    31293.583    730.33185    730.33185 
Loop time of 130.671 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.297 hours/ns, 7.653 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    | 130.06     | 130.06     | 130.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10948    | 0.10948    | 0.10948    |   0.0 |  0.08
Output  | 0.00015773 | 0.00015773 | 0.00015773 |   0.0 |  0.00
Modify  | 0.44064    | 0.44064    | 0.44064    |   0.0 |  0.34
Other   |            | 0.06544    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.933683106282, Press = -0.493873305046633
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  162000   -13476.577   -13476.577   -13548.206   -13548.206    277.21196    277.21196    31293.583    31293.583    730.33185    730.33185 
  163000   -13478.243   -13478.243   -13548.277   -13548.277    271.03917    271.03917    31274.289    31274.289     2257.817     2257.817 
Loop time of 130.368 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.213 hours/ns, 7.671 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    | 129.75     | 129.75     | 129.75     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10925    | 0.10925    | 0.10925    |   0.0 |  0.08
Output  | 0.00020536 | 0.00020536 | 0.00020536 |   0.0 |  0.00
Modify  | 0.4385     | 0.4385     | 0.4385     |   0.0 |  0.34
Other   |            | 0.0658     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.932552514947, Press = -0.330794466002212
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  163000   -13478.243   -13478.243   -13548.277   -13548.277    271.03917    271.03917    31274.289    31274.289     2257.817     2257.817 
  164000   -13475.685   -13475.685   -13547.731   -13547.731    278.82393    278.82393    31287.158    31287.158    1326.0658    1326.0658 
Loop time of 130.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.283 hours/ns, 7.656 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    | 130        | 130        | 130        |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10954    | 0.10954    | 0.10954    |   0.0 |  0.08
Output  | 0.0002052  | 0.0002052  | 0.0002052  |   0.0 |  0.00
Modify  | 0.44383    | 0.44383    | 0.44383    |   0.0 |  0.34
Other   |            | 0.06589    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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 = 272.940030668825, Press = -0.102408718970542
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  164000   -13475.685   -13475.685   -13547.731   -13547.731    278.82393    278.82393    31287.158    31287.158    1326.0658    1326.0658 
  165000    -13477.23    -13477.23   -13547.738   -13547.738    272.87397    272.87397    31279.636    31279.636    1927.4341    1927.4341 
Loop time of 130.823 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.340 hours/ns, 7.644 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    | 130.21     | 130.21     | 130.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10991    | 0.10991    | 0.10991    |   0.0 |  0.08
Output  | 0.00015571 | 0.00015571 | 0.00015571 |   0.0 |  0.00
Modify  | 0.43491    | 0.43491    | 0.43491    |   0.0 |  0.33
Other   |            | 0.06539    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.940631264087, Press = -0.017499362868387
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  165000    -13477.23    -13477.23   -13547.738   -13547.738    272.87397    272.87397    31279.636    31279.636    1927.4341    1927.4341 
  166000   -13478.409   -13478.409   -13548.429   -13548.429    270.98522    270.98522    31280.852    31280.852    1460.2832    1460.2832 
Loop time of 130.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.297 hours/ns, 7.653 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    | 130.05     | 130.05     | 130.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10939    | 0.10939    | 0.10939    |   0.0 |  0.08
Output  | 0.00015732 | 0.00015732 | 0.00015732 |   0.0 |  0.00
Modify  | 0.44059    | 0.44059    | 0.44059    |   0.0 |  0.34
Other   |            | 0.06532    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.946342986584, Press = 0.124560274711485
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  166000   -13478.409   -13478.409   -13548.429   -13548.429    270.98522    270.98522    31280.852    31280.852    1460.2832    1460.2832 
  167000   -13473.548   -13473.548   -13545.855   -13545.855    279.83489    279.83489    31302.597    31302.597    226.73863    226.73863 
Loop time of 130.754 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.321 hours/ns, 7.648 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    | 130.14     | 130.14     | 130.14     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10962    | 0.10962    | 0.10962    |   0.0 |  0.08
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.44104    | 0.44104    | 0.44104    |   0.0 |  0.34
Other   |            | 0.06596    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
31301.1140550696

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0