# 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 2.86696694791317*${_u_distance}
variable latticeconst_converted equal 2.86696694791317*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86696694791317
Lattice spacing in x,y,z = 2.8669669 2.8669669 2.8669669
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 (28.669669 28.669669 28.669669)
  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 (28.669669 28.669669 28.669669)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_BelandTammMu_2017_FeNiCr__MO_715003088863_000
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -7928.1573   -7928.1573   -8009.0725   -8009.0725       313.15       313.15    23565.033    23565.033    3667.5768    3667.5768 
    1000   -7976.8859   -7976.8859    -8056.278    -8056.278     307.2556     307.2556    21633.693    21633.693   -339.10825   -339.10825 
Loop time of 31.6791 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.727 ns/day, 8.800 hours/ns, 31.567 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    | 30.991     | 30.991     | 30.991     |   0.0 | 97.83
Neigh   | 0.14342    | 0.14342    | 0.14342    |   0.0 |  0.45
Comm    | 0.12912    | 0.12912    | 0.12912    |   0.0 |  0.41
Output  | 0.00019415 | 0.00019415 | 0.00019415 |   0.0 |  0.00
Modify  | 0.35031    | 0.35031    | 0.35031    |   0.0 |  1.11
Other   |            | 0.06505    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5471.00 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332726.0 ave      332726 max      332726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332726
Ave neighs/atom = 166.36300
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7976.8859   -7976.8859    -8056.278    -8056.278     307.2556     307.2556    21633.693    21633.693   -339.10825   -339.10825 
    2000   -8006.1702   -8006.1702   -8089.1236   -8089.1236    321.03801    321.03801    21636.774    21636.774   -337.33324   -337.33324 
Loop time of 32.395 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.667 ns/day, 8.999 hours/ns, 30.869 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    | 31.751     | 31.751     | 31.751     |   0.0 | 98.01
Neigh   | 0.094857   | 0.094857   | 0.094857   |   0.0 |  0.29
Comm    | 0.12872    | 0.12872    | 0.12872    |   0.0 |  0.40
Output  | 0.00022057 | 0.00022057 | 0.00022057 |   0.0 |  0.00
Modify  | 0.35492    | 0.35492    | 0.35492    |   0.0 |  1.10
Other   |            | 0.06568    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5454.00 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331736.0 ave      331736 max      331736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331736
Ave neighs/atom = 165.86800
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8006.1702   -8006.1702   -8089.1236   -8089.1236    321.03801    321.03801    21636.774    21636.774   -337.33324   -337.33324 
    3000   -8013.7833   -8013.7833   -8094.6829   -8094.6829    313.09004    313.09004    21594.326    21594.326    1659.9128    1659.9128 
Loop time of 31.9843 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.701 ns/day, 8.885 hours/ns, 31.265 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    | 31.397     | 31.397     | 31.397     |   0.0 | 98.17
Neigh   | 0.04714    | 0.04714    | 0.04714    |   0.0 |  0.15
Comm    | 0.12532    | 0.12532    | 0.12532    |   0.0 |  0.39
Output  | 0.00018403 | 0.00018403 | 0.00018403 |   0.0 |  0.00
Modify  | 0.34913    | 0.34913    | 0.34913    |   0.0 |  1.09
Other   |            | 0.06506    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332102.0 ave      332102 max      332102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332102
Ave neighs/atom = 166.05100
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8013.7833   -8013.7833   -8094.6829   -8094.6829    313.09004    313.09004    21594.326    21594.326    1659.9128    1659.9128 
    4000   -8010.7957   -8010.7957   -8094.3087   -8094.3087    323.20402    323.20402     21569.73     21569.73     2906.209     2906.209 
Loop time of 32.8202 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.117 hours/ns, 30.469 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    | 32.267     | 32.267     | 32.267     |   0.0 | 98.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12784    | 0.12784    | 0.12784    |   0.0 |  0.39
Output  | 0.00019075 | 0.00019075 | 0.00019075 |   0.0 |  0.00
Modify  | 0.36009    | 0.36009    | 0.36009    |   0.0 |  1.10
Other   |            | 0.06551    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5447.00 ave        5447 max        5447 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331656.0 ave      331656 max      331656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331656
Ave neighs/atom = 165.82800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8010.7957   -8010.7957   -8094.3087   -8094.3087    323.20402    323.20402     21569.73     21569.73     2906.209     2906.209 
    5000    -8014.618    -8014.618   -8094.2981   -8094.2981    308.37026    308.37026    21619.276    21619.276   -176.71961   -176.71961 
Loop time of 32.4335 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.664 ns/day, 9.009 hours/ns, 30.832 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    | 31.884     | 31.884     | 31.884     |   0.0 | 98.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12562    | 0.12562    | 0.12562    |   0.0 |  0.39
Output  | 0.0001528  | 0.0001528  | 0.0001528  |   0.0 |  0.00
Modify  | 0.35808    | 0.35808    | 0.35808    |   0.0 |  1.10
Other   |            | 0.06558    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332282.0 ave      332282 max      332282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332282
Ave neighs/atom = 166.14100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.138684061561, Press = 228.2701365461
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -8014.618    -8014.618   -8094.2981   -8094.2981    308.37026    308.37026    21619.276    21619.276   -176.71961   -176.71961 
    6000   -8017.1579   -8017.1579   -8097.0504   -8097.0504    309.19218    309.19218    21605.689    21605.689    408.78187    408.78187 
Loop time of 32.3608 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.670 ns/day, 8.989 hours/ns, 30.902 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    | 31.8       | 31.8       | 31.8       |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12611    | 0.12611    | 0.12611    |   0.0 |  0.39
Output  | 0.00020187 | 0.00020187 | 0.00020187 |   0.0 |  0.00
Modify  | 0.3706     | 0.3706     | 0.3706     |   0.0 |  1.15
Other   |            | 0.06439    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331604.0 ave      331604 max      331604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331604
Ave neighs/atom = 165.80200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.994340823632, Press = -6.33881069036822
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8017.1579   -8017.1579   -8097.0504   -8097.0504    309.19218    309.19218    21605.689    21605.689    408.78187    408.78187 
    7000    -8013.637    -8013.637    -8096.112    -8096.112    319.18691    319.18691    21601.672    21601.672      793.238      793.238 
Loop time of 33.2051 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.602 ns/day, 9.224 hours/ns, 30.116 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    | 32.623     | 32.623     | 32.623     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12989    | 0.12989    | 0.12989    |   0.0 |  0.39
Output  | 0.00015176 | 0.00015176 | 0.00015176 |   0.0 |  0.00
Modify  | 0.38572    | 0.38572    | 0.38572    |   0.0 |  1.16
Other   |            | 0.06587    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331828.0 ave      331828 max      331828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331828
Ave neighs/atom = 165.91400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.026922174625, Press = 0.147804606054413
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -8013.637    -8013.637    -8096.112    -8096.112    319.18691    319.18691    21601.672    21601.672      793.238      793.238 
    8000   -8011.9064   -8011.9064   -8094.0657   -8094.0657    317.96482    317.96482    21582.108    21582.108    2172.6906    2172.6906 
Loop time of 31.9378 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.705 ns/day, 8.872 hours/ns, 31.311 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    | 31.381     | 31.381     | 31.381     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12449    | 0.12449    | 0.12449    |   0.0 |  0.39
Output  | 0.00015541 | 0.00015541 | 0.00015541 |   0.0 |  0.00
Modify  | 0.36747    | 0.36747    | 0.36747    |   0.0 |  1.15
Other   |            | 0.06494    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331778.0 ave      331778 max      331778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331778
Ave neighs/atom = 165.88900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.342344834064, Press = -4.79988549351754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8011.9064   -8011.9064   -8094.0657   -8094.0657    317.96482    317.96482    21582.108    21582.108    2172.6906    2172.6906 
    9000   -8015.2682   -8015.2682   -8096.0386   -8096.0386    312.58979    312.58979    21629.179    21629.179   -1560.0555   -1560.0555 
Loop time of 32.7663 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.102 hours/ns, 30.519 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    | 32.193     | 32.193     | 32.193     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.39
Output  | 0.00015092 | 0.00015092 | 0.00015092 |   0.0 |  0.00
Modify  | 0.38009    | 0.38009    | 0.38009    |   0.0 |  1.16
Other   |            | 0.06538    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331960.0 ave      331960 max      331960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331960
Ave neighs/atom = 165.98000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.46143774532, Press = 8.02976610885459
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8015.2682   -8015.2682   -8096.0386   -8096.0386    312.58979    312.58979    21629.179    21629.179   -1560.0555   -1560.0555 
   10000   -8010.9256   -8010.9256   -8091.9954   -8091.9954    313.74859    313.74859    21656.046    21656.046   -1829.4731   -1829.4731 
Loop time of 32.6619 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.645 ns/day, 9.073 hours/ns, 30.617 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    | 32.092     | 32.092     | 32.092     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12726    | 0.12726    | 0.12726    |   0.0 |  0.39
Output  | 0.00015966 | 0.00015966 | 0.00015966 |   0.0 |  0.00
Modify  | 0.37687    | 0.37687    | 0.37687    |   0.0 |  1.15
Other   |            | 0.06558    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331362.0 ave      331362 max      331362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331362
Ave neighs/atom = 165.68100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.296211425962, Press = 5.52621447122724
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8010.9256   -8010.9256   -8091.9954   -8091.9954    313.74859    313.74859    21656.046    21656.046   -1829.4731   -1829.4731 
   11000    -8015.124    -8015.124   -8095.0749   -8095.0749    309.41813    309.41813    21641.083    21641.083   -1415.3773   -1415.3773 
Loop time of 32.1036 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.691 ns/day, 8.918 hours/ns, 31.149 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    | 31.541     | 31.541     | 31.541     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12555    | 0.12555    | 0.12555    |   0.0 |  0.39
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.37156    | 0.37156    | 0.37156    |   0.0 |  1.16
Other   |            | 0.06492    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330954.0 ave      330954 max      330954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330954
Ave neighs/atom = 165.47700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.319867041867, Press = -5.55691526335085
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -8015.124    -8015.124   -8095.0749   -8095.0749    309.41813    309.41813    21641.083    21641.083   -1415.3773   -1415.3773 
   12000   -8012.0864   -8012.0864    -8093.409    -8093.409    314.72667    314.72667    21627.621    21627.621   -434.93294   -434.93294 
Loop time of 32.8854 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.627 ns/day, 9.135 hours/ns, 30.409 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    | 32.323     | 32.323     | 32.323     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12617    | 0.12617    | 0.12617    |   0.0 |  0.38
Output  | 0.0001546  | 0.0001546  | 0.0001546  |   0.0 |  0.00
Modify  | 0.37217    | 0.37217    | 0.37217    |   0.0 |  1.13
Other   |            | 0.06436    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331370.0 ave      331370 max      331370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331370
Ave neighs/atom = 165.68500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.547799208908, Press = -10.0334565593682
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8012.0864   -8012.0864    -8093.409    -8093.409    314.72667    314.72667    21627.621    21627.621   -434.93294   -434.93294 
   13000   -8013.6073   -8013.6073   -8096.2748   -8096.2748     319.9319     319.9319    21591.548    21591.548   -18.530643   -18.530643 
Loop time of 33.4774 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.581 ns/day, 9.299 hours/ns, 29.871 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    | 32.898     | 32.898     | 32.898     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12895    | 0.12895    | 0.12895    |   0.0 |  0.39
Output  | 0.00015333 | 0.00015333 | 0.00015333 |   0.0 |  0.00
Modify  | 0.38437    | 0.38437    | 0.38437    |   0.0 |  1.15
Other   |            | 0.06592    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331608.0 ave      331608 max      331608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331608
Ave neighs/atom = 165.80400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.682834129834, Press = 8.62843334704849
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8013.6073   -8013.6073   -8096.2748   -8096.2748     319.9319     319.9319    21591.548    21591.548   -18.530643   -18.530643 
   14000   -8013.2398   -8013.2398   -8094.4982   -8094.4982    314.47837    314.47837    21635.796    21635.796   -474.43869   -474.43869 
Loop time of 32.0542 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.695 ns/day, 8.904 hours/ns, 31.197 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    | 31.497     | 31.497     | 31.497     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12443    | 0.12443    | 0.12443    |   0.0 |  0.39
Output  | 0.00015545 | 0.00015545 | 0.00015545 |   0.0 |  0.00
Modify  | 0.36753    | 0.36753    | 0.36753    |   0.0 |  1.15
Other   |            | 0.06511    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332076.0 ave      332076 max      332076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332076
Ave neighs/atom = 166.03800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.888385629149, Press = -10.1223378505187
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8013.2398   -8013.2398   -8094.4982   -8094.4982    314.47837    314.47837    21635.796    21635.796   -474.43869   -474.43869 
   15000   -8014.0503   -8014.0503   -8094.8598   -8094.8598    312.74099    312.74099    21609.382    21609.382     25.14534     25.14534 
Loop time of 33.2532 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.598 ns/day, 9.237 hours/ns, 30.072 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    | 32.68      | 32.68      | 32.68      |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1271     | 0.1271     | 0.1271     |   0.0 |  0.38
Output  | 0.00015672 | 0.00015672 | 0.00015672 |   0.0 |  0.00
Modify  | 0.38071    | 0.38071    | 0.38071    |   0.0 |  1.14
Other   |            | 0.06515    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331232.0 ave      331232 max      331232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331232
Ave neighs/atom = 165.61600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.769933298084, Press = -2.14663970888057
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8014.0503   -8014.0503   -8094.8598   -8094.8598    312.74099    312.74099    21609.382    21609.382     25.14534     25.14534 
   16000   -8014.2432   -8014.2432   -8096.4708   -8096.4708    318.22922    318.22922    21592.548    21592.548    1024.1076    1024.1076 
Loop time of 32.5294 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.656 ns/day, 9.036 hours/ns, 30.741 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    | 31.966     | 31.966     | 31.966     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12671    | 0.12671    | 0.12671    |   0.0 |  0.39
Output  | 0.00023769 | 0.00023769 | 0.00023769 |   0.0 |  0.00
Modify  | 0.37083    | 0.37083    | 0.37083    |   0.0 |  1.14
Other   |            | 0.06512    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331806.0 ave      331806 max      331806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331806
Ave neighs/atom = 165.90300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.584378045128, Press = -2.45327765928474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8014.2432   -8014.2432   -8096.4708   -8096.4708    318.22922    318.22922    21592.548    21592.548    1024.1076    1024.1076 
   17000   -8014.8574   -8014.8574    -8096.214    -8096.214    314.85876    314.85876    21624.791    21624.791   -569.65598   -569.65598 
Loop time of 33.1698 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.605 ns/day, 9.214 hours/ns, 30.148 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    | 32.593     | 32.593     | 32.593     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12798    | 0.12798    | 0.12798    |   0.0 |  0.39
Output  | 0.00023285 | 0.00023285 | 0.00023285 |   0.0 |  0.00
Modify  | 0.3826     | 0.3826     | 0.3826     |   0.0 |  1.15
Other   |            | 0.06568    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331938.0 ave      331938 max      331938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331938
Ave neighs/atom = 165.96900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.413950903862, Press = 0.449708828124916
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8014.8574   -8014.8574    -8096.214    -8096.214    314.85876    314.85876    21624.791    21624.791   -569.65598   -569.65598 
   18000   -8017.9174   -8017.9174   -8097.7813   -8097.7813    309.08136    309.08136    21571.609    21571.609    1412.7849    1412.7849 
Loop time of 32.6891 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.643 ns/day, 9.080 hours/ns, 30.591 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    | 32.123     | 32.123     | 32.123     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12579    | 0.12579    | 0.12579    |   0.0 |  0.38
Output  | 0.00014973 | 0.00014973 | 0.00014973 |   0.0 |  0.00
Modify  | 0.3747     | 0.3747     | 0.3747     |   0.0 |  1.15
Other   |            | 0.06556    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331780.0 ave      331780 max      331780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331780
Ave neighs/atom = 165.89000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.226982466075, Press = -3.46124900662951
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8017.9174   -8017.9174   -8097.7813   -8097.7813    309.08136    309.08136    21571.609    21571.609    1412.7849    1412.7849 
   19000   -8013.0299   -8013.0299   -8095.5434   -8095.5434    319.33577    319.33577    21598.728    21598.728   -718.00568   -718.00568 
Loop time of 33.5872 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.572 ns/day, 9.330 hours/ns, 29.773 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    | 33.004     | 33.004     | 33.004     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12874    | 0.12874    | 0.12874    |   0.0 |  0.38
Output  | 0.00019826 | 0.00019826 | 0.00019826 |   0.0 |  0.00
Modify  | 0.38813    | 0.38813    | 0.38813    |   0.0 |  1.16
Other   |            | 0.06601    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332708.0 ave      332708 max      332708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332708
Ave neighs/atom = 166.35400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.191626912205, Press = 3.04798890750529
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8013.0299   -8013.0299   -8095.5434   -8095.5434    319.33577    319.33577    21598.728    21598.728   -718.00568   -718.00568 
   20000   -8014.9956   -8014.9956   -8096.0797   -8096.0797    313.80415    313.80415    21568.125    21568.125    3103.6787    3103.6787 
Loop time of 32.8464 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.630 ns/day, 9.124 hours/ns, 30.445 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    | 32.275     | 32.275     | 32.275     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12734    | 0.12734    | 0.12734    |   0.0 |  0.39
Output  | 0.0001551  | 0.0001551  | 0.0001551  |   0.0 |  0.00
Modify  | 0.37828    | 0.37828    | 0.37828    |   0.0 |  1.15
Other   |            | 0.06525    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331838.0 ave      331838 max      331838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331838
Ave neighs/atom = 165.91900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.249217642019, Press = 5.35870564811843
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8014.9956   -8014.9956   -8096.0797   -8096.0797    313.80415    313.80415    21568.125    21568.125    3103.6787    3103.6787 
   21000   -8013.7422   -8013.7422   -8092.6746   -8092.6746    305.47658    305.47658    21675.998    21675.998   -2873.7172   -2873.7172 
Loop time of 31.8959 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.709 ns/day, 8.860 hours/ns, 31.352 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    | 31.335     | 31.335     | 31.335     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12441    | 0.12441    | 0.12441    |   0.0 |  0.39
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.37085    | 0.37085    | 0.37085    |   0.0 |  1.16
Other   |            | 0.06515    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5420.00 ave        5420 max        5420 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332214.0 ave      332214 max      332214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332214
Ave neighs/atom = 166.10700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.351202367471, Press = -4.82870720506373
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8013.7422   -8013.7422   -8092.6746   -8092.6746    305.47658    305.47658    21675.998    21675.998   -2873.7172   -2873.7172 
   22000    -8013.709    -8013.709   -8094.3546   -8094.3546    312.10688    312.10688    21605.553    21605.553    893.36175    893.36175 
Loop time of 33.5201 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.578 ns/day, 9.311 hours/ns, 29.833 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    | 32.934     | 32.934     | 32.934     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13067    | 0.13067    | 0.13067    |   0.0 |  0.39
Output  | 0.00020249 | 0.00020249 | 0.00020249 |   0.0 |  0.00
Modify  | 0.38965    | 0.38965    | 0.38965    |   0.0 |  1.16
Other   |            | 0.06609    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330810.0 ave      330810 max      330810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330810
Ave neighs/atom = 165.40500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.468889456095, Press = -3.75270128691785
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -8013.709    -8013.709   -8094.3546   -8094.3546    312.10688    312.10688    21605.553    21605.553    893.36175    893.36175 
   23000   -8012.9777   -8012.9777    -8093.089    -8093.089    310.03873    310.03873    21621.317    21621.317   -379.08297   -379.08297 
Loop time of 32.6183 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.649 ns/day, 9.061 hours/ns, 30.658 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    | 32.044     | 32.044     | 32.044     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12793    | 0.12793    | 0.12793    |   0.0 |  0.39
Output  | 0.00019414 | 0.00019414 | 0.00019414 |   0.0 |  0.00
Modify  | 0.38048    | 0.38048    | 0.38048    |   0.0 |  1.17
Other   |            | 0.06562    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331762.0 ave      331762 max      331762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331762
Ave neighs/atom = 165.88100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.508888628724, Press = -0.985339467381698
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8012.9777   -8012.9777    -8093.089    -8093.089    310.03873    310.03873    21621.317    21621.317   -379.08297   -379.08297 
   24000   -8012.2266   -8012.2266   -8094.8189   -8094.8189    319.64102    319.64102    21582.215    21582.215    2255.9648    2255.9648 
Loop time of 33.1889 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.603 ns/day, 9.219 hours/ns, 30.131 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    | 32.614     | 32.614     | 32.614     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12773    | 0.12773    | 0.12773    |   0.0 |  0.38
Output  | 0.00015309 | 0.00015309 | 0.00015309 |   0.0 |  0.00
Modify  | 0.38111    | 0.38111    | 0.38111    |   0.0 |  1.15
Other   |            | 0.06556    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5447.00 ave        5447 max        5447 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331502.0 ave      331502 max      331502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331502
Ave neighs/atom = 165.75100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.631342480197, Press = -0.286849348990442
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8012.2266   -8012.2266   -8094.8189   -8094.8189    319.64102    319.64102    21582.215    21582.215    2255.9648    2255.9648 
   25000   -8014.3556   -8014.3556   -8094.1382   -8094.1382    308.76725    308.76725    21604.629    21604.629    903.57277    903.57277 
Loop time of 33.143 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.607 ns/day, 9.206 hours/ns, 30.172 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    | 32.565     | 32.565     | 32.565     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12793    | 0.12793    | 0.12793    |   0.0 |  0.39
Output  | 0.00019779 | 0.00019779 | 0.00019779 |   0.0 |  0.00
Modify  | 0.3841     | 0.3841     | 0.3841     |   0.0 |  1.16
Other   |            | 0.06557    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332304.0 ave      332304 max      332304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332304
Ave neighs/atom = 166.15200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.618842001182, Press = 1.94488287197135
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8014.3556   -8014.3556   -8094.1382   -8094.1382    308.76725    308.76725    21604.629    21604.629    903.57277    903.57277 
   26000    -8014.962    -8014.962    -8095.308    -8095.308    310.94734    310.94734    21632.774    21632.774   -455.17034   -455.17034 
Loop time of 33.4266 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.585 ns/day, 9.285 hours/ns, 29.916 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    | 32.844     | 32.844     | 32.844     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12925    | 0.12925    | 0.12925    |   0.0 |  0.39
Output  | 0.00020355 | 0.00020355 | 0.00020355 |   0.0 |  0.00
Modify  | 0.38719    | 0.38719    | 0.38719    |   0.0 |  1.16
Other   |            | 0.06609    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331908.0 ave      331908 max      331908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331908
Ave neighs/atom = 165.95400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.709424484171, Press = -0.75350392013307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -8014.962    -8014.962    -8095.308    -8095.308    310.94734    310.94734    21632.774    21632.774   -455.17034   -455.17034 
   27000   -8012.2283   -8012.2283   -8094.4509   -8094.4509    318.20974    318.20974    21644.064    21644.064   -2248.1725   -2248.1725 
Loop time of 32.2892 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.676 ns/day, 8.969 hours/ns, 30.970 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    | 31.723     | 31.723     | 31.723     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12731    | 0.12731    | 0.12731    |   0.0 |  0.39
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.3731     | 0.3731     | 0.3731     |   0.0 |  1.16
Other   |            | 0.06542    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5454.00 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331280.0 ave      331280 max      331280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331280
Ave neighs/atom = 165.64000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.735573206766, Press = 0.474521725182754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8012.2283   -8012.2283   -8094.4509   -8094.4509    318.20974    318.20974    21644.064    21644.064   -2248.1725   -2248.1725 
   28000   -8014.7562   -8014.7562   -8094.2542   -8094.2542    307.66571    307.66571    21587.692    21587.692    2267.8084    2267.8084 
Loop time of 33.9353 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.546 ns/day, 9.426 hours/ns, 29.468 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    | 33.352     | 33.352     | 33.352     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12916    | 0.12916    | 0.12916    |   0.0 |  0.38
Output  | 0.00015272 | 0.00015272 | 0.00015272 |   0.0 |  0.00
Modify  | 0.38881    | 0.38881    | 0.38881    |   0.0 |  1.15
Other   |            | 0.06535    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5426.00 ave        5426 max        5426 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331062.0 ave      331062 max      331062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331062
Ave neighs/atom = 165.53100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.838804662994, Press = -0.698036767325965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8014.7562   -8014.7562   -8094.2542   -8094.2542    307.66571    307.66571    21587.692    21587.692    2267.8084    2267.8084 
   29000   -8014.8539   -8014.8539   -8094.8709   -8094.8709    309.67426    309.67426    21630.596    21630.596   -1005.4325   -1005.4325 
Loop time of 32.9443 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.623 ns/day, 9.151 hours/ns, 30.354 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    | 32.372     | 32.372     | 32.372     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12746    | 0.12746    | 0.12746    |   0.0 |  0.39
Output  | 0.00015394 | 0.00015394 | 0.00015394 |   0.0 |  0.00
Modify  | 0.37949    | 0.37949    | 0.37949    |   0.0 |  1.15
Other   |            | 0.06564    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332126.0 ave      332126 max      332126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332126
Ave neighs/atom = 166.06300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.844929145996, Press = -0.411211154585426
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8014.8539   -8014.8539   -8094.8709   -8094.8709    309.67426    309.67426    21630.596    21630.596   -1005.4325   -1005.4325 
   30000   -8017.1674   -8017.1674   -8096.2431   -8096.2431      306.031      306.031    21581.777    21581.777    2167.6247    2167.6247 
Loop time of 33.3173 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.593 ns/day, 9.255 hours/ns, 30.014 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    | 32.738     | 32.738     | 32.738     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12813    | 0.12813    | 0.12813    |   0.0 |  0.38
Output  | 0.00015473 | 0.00015473 | 0.00015473 |   0.0 |  0.00
Modify  | 0.385      | 0.385      | 0.385      |   0.0 |  1.16
Other   |            | 0.06564    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331434.0 ave      331434 max      331434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331434
Ave neighs/atom = 165.71700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.79055915329, Press = 3.00027090911763
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8017.1674   -8017.1674   -8096.2431   -8096.2431      306.031      306.031    21581.777    21581.777    2167.6247    2167.6247 
   31000   -8009.7158   -8009.7158   -8091.9405   -8091.9405     318.2178     318.2178    21603.057    21603.057    937.19253    937.19253 
Loop time of 33.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.547 ns/day, 9.422 hours/ns, 29.480 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    | 33.335     | 33.335     | 33.335     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12999    | 0.12999    | 0.12999    |   0.0 |  0.38
Output  | 0.00015473 | 0.00015473 | 0.00015473 |   0.0 |  0.00
Modify  | 0.38969    | 0.38969    | 0.38969    |   0.0 |  1.15
Other   |            | 0.06568    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332306.0 ave      332306 max      332306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332306
Ave neighs/atom = 166.15300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.839363829125, Press = 1.47744630853421
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8009.7158   -8009.7158   -8091.9405   -8091.9405     318.2178     318.2178    21603.057    21603.057    937.19253    937.19253 
   32000    -8016.701    -8016.701   -8096.8196   -8096.8196     310.0671     310.0671    21637.077    21637.077   -3183.5036   -3183.5036 
Loop time of 32.5152 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.657 ns/day, 9.032 hours/ns, 30.755 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    | 31.949     | 31.949     | 31.949     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12612    | 0.12612    | 0.12612    |   0.0 |  0.39
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.37401    | 0.37401    | 0.37401    |   0.0 |  1.15
Other   |            | 0.06541    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5452.00 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331672.0 ave      331672 max      331672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331672
Ave neighs/atom = 165.83600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.832384836201, Press = -0.0591723163285009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -8016.701    -8016.701   -8096.8196   -8096.8196     310.0671     310.0671    21637.077    21637.077   -3183.5036   -3183.5036 
   33000   -8013.1457   -8013.1457   -8095.7158   -8095.7158    319.55485    319.55485    21601.562    21601.562   -125.06574   -125.06574 
Loop time of 33.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.578 ns/day, 9.309 hours/ns, 29.841 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    | 32.931     | 32.931     | 32.931     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12826    | 0.12826    | 0.12826    |   0.0 |  0.38
Output  | 0.0001921  | 0.0001921  | 0.0001921  |   0.0 |  0.00
Modify  | 0.38618    | 0.38618    | 0.38618    |   0.0 |  1.15
Other   |            | 0.06553    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5447.00 ave        5447 max        5447 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331140.0 ave      331140 max      331140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331140
Ave neighs/atom = 165.57000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.879463955768, Press = -2.33498749888333
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8013.1457   -8013.1457   -8095.7158   -8095.7158    319.55485    319.55485    21601.562    21601.562   -125.06574   -125.06574 
   34000   -8010.4797   -8010.4797   -8094.8552   -8094.8552    326.54191    326.54191    21606.809    21606.809    154.55859    154.55859 
Loop time of 33.2427 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.599 ns/day, 9.234 hours/ns, 30.082 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    | 32.665     | 32.665     | 32.665     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1292     | 0.1292     | 0.1292     |   0.0 |  0.39
Output  | 0.00015777 | 0.00015777 | 0.00015777 |   0.0 |  0.00
Modify  | 0.38326    | 0.38326    | 0.38326    |   0.0 |  1.15
Other   |            | 0.06546    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5447.00 ave        5447 max        5447 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331770.0 ave      331770 max      331770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331770
Ave neighs/atom = 165.88500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.909703336993, Press = 1.24202720965447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8010.4797   -8010.4797   -8094.8552   -8094.8552    326.54191    326.54191    21606.809    21606.809    154.55859    154.55859 
   35000   -8016.2588   -8016.2588   -8098.0868   -8098.0868    316.68278    316.68278    21534.327    21534.327    2585.2063    2585.2063 
Loop time of 32.9215 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.624 ns/day, 9.145 hours/ns, 30.375 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    | 32.351     | 32.351     | 32.351     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12772    | 0.12772    | 0.12772    |   0.0 |  0.39
Output  | 0.00015432 | 0.00015432 | 0.00015432 |   0.0 |  0.00
Modify  | 0.37714    | 0.37714    | 0.37714    |   0.0 |  1.15
Other   |            | 0.06545    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332008.0 ave      332008 max      332008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332008
Ave neighs/atom = 166.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.943182499275, Press = 0.872875750016366
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8016.2588   -8016.2588   -8098.0868   -8098.0868    316.68278    316.68278    21534.327    21534.327    2585.2063    2585.2063 
   36000    -8010.058    -8010.058   -8093.1698   -8093.1698     321.6512     321.6512     21588.78     21588.78    2654.7019    2654.7019 
Loop time of 32.5375 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.655 ns/day, 9.038 hours/ns, 30.734 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    | 31.969     | 31.969     | 31.969     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12747    | 0.12747    | 0.12747    |   0.0 |  0.39
Output  | 0.00020121 | 0.00020121 | 0.00020121 |   0.0 |  0.00
Modify  | 0.37497    | 0.37497    | 0.37497    |   0.0 |  1.15
Other   |            | 0.06593    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5464.00 ave        5464 max        5464 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332646.0 ave      332646 max      332646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332646
Ave neighs/atom = 166.32300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.96932685227, Press = -0.13284571069383
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -8010.058    -8010.058   -8093.1698   -8093.1698     321.6512     321.6512     21588.78     21588.78    2654.7019    2654.7019 
   37000    -8015.041    -8015.041   -8097.1611   -8097.1611    317.81333    317.81333    21565.936    21565.936      2372.64      2372.64 
Loop time of 33.1481 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.606 ns/day, 9.208 hours/ns, 30.168 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    | 32.573     | 32.573     | 32.573     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12845    | 0.12845    | 0.12845    |   0.0 |  0.39
Output  | 0.00014718 | 0.00014718 | 0.00014718 |   0.0 |  0.00
Modify  | 0.38075    | 0.38075    | 0.38075    |   0.0 |  1.15
Other   |            | 0.06558    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5428.00 ave        5428 max        5428 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332152.0 ave      332152 max      332152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332152
Ave neighs/atom = 166.07600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.014471911483, Press = -0.720276958235566
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    -8015.041    -8015.041   -8097.1611   -8097.1611    317.81333    317.81333    21565.936    21565.936      2372.64      2372.64 
   38000   -8016.9496   -8016.9496   -8096.5274   -8096.5274    307.97434    307.97434    21641.757    21641.757   -1891.3172   -1891.3172 
Loop time of 33.5576 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.575 ns/day, 9.322 hours/ns, 29.800 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    | 32.969     | 32.969     | 32.969     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13034    | 0.13034    | 0.13034    |   0.0 |  0.39
Output  | 0.00015275 | 0.00015275 | 0.00015275 |   0.0 |  0.00
Modify  | 0.39219    | 0.39219    | 0.39219    |   0.0 |  1.17
Other   |            | 0.06591    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332050.0 ave      332050 max      332050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332050
Ave neighs/atom = 166.02500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.030475527045, Press = 0.787122373569512
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8016.9496   -8016.9496   -8096.5274   -8096.5274    307.97434    307.97434    21641.757    21641.757   -1891.3172   -1891.3172 
   39000   -8013.0733   -8013.0733   -8094.2873   -8094.2873    314.30683    314.30683    21643.493    21643.493   -2551.6882   -2551.6882 
Loop time of 31.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.876 hours/ns, 31.294 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    | 31.392     | 31.392     | 31.392     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12577    | 0.12577    | 0.12577    |   0.0 |  0.39
Output  | 0.00018647 | 0.00018647 | 0.00018647 |   0.0 |  0.00
Modify  | 0.37164    | 0.37164    | 0.37164    |   0.0 |  1.16
Other   |            | 0.06541    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331236.0 ave      331236 max      331236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331236
Ave neighs/atom = 165.61800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.960274147985, Press = 0.165260627278064
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8013.0733   -8013.0733   -8094.2873   -8094.2873    314.30683    314.30683    21643.493    21643.493   -2551.6882   -2551.6882 
   40000   -8014.7636   -8014.7636   -8096.1055   -8096.1055    314.80187    314.80187    21611.155    21611.155    18.739464    18.739464 
Loop time of 32.7796 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.105 hours/ns, 30.507 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    | 32.206     | 32.206     | 32.206     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12763    | 0.12763    | 0.12763    |   0.0 |  0.39
Output  | 0.00015522 | 0.00015522 | 0.00015522 |   0.0 |  0.00
Modify  | 0.38024    | 0.38024    | 0.38024    |   0.0 |  1.16
Other   |            | 0.06543    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331022.0 ave      331022 max      331022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331022
Ave neighs/atom = 165.51100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.879558760999, Press = -2.45892888059445
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8014.7636   -8014.7636   -8096.1055   -8096.1055    314.80187    314.80187    21611.155    21611.155    18.739464    18.739464 
   41000   -8015.9155   -8015.9155   -8096.1986   -8096.1986    310.70369    310.70369    21589.659    21589.659    754.84902    754.84902 
Loop time of 33.5804 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.573 ns/day, 9.328 hours/ns, 29.779 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    | 32.999     | 32.999     | 32.999     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1288     | 0.1288     | 0.1288     |   0.0 |  0.38
Output  | 0.00015582 | 0.00015582 | 0.00015582 |   0.0 |  0.00
Modify  | 0.38594    | 0.38594    | 0.38594    |   0.0 |  1.15
Other   |            | 0.06609    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331752.0 ave      331752 max      331752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331752
Ave neighs/atom = 165.87600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.909524905951, Press = -0.051120820076667
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8015.9155   -8015.9155   -8096.1986   -8096.1986    310.70369    310.70369    21589.659    21589.659    754.84902    754.84902 
   42000   -8012.9227   -8012.9227   -8093.2396   -8093.2396    310.83487    310.83487    21618.752    21618.752    -434.6437    -434.6437 
Loop time of 33.2154 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.601 ns/day, 9.226 hours/ns, 30.107 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    | 32.637     | 32.637     | 32.637     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12819    | 0.12819    | 0.12819    |   0.0 |  0.39
Output  | 0.00019494 | 0.00019494 | 0.00019494 |   0.0 |  0.00
Modify  | 0.38406    | 0.38406    | 0.38406    |   0.0 |  1.16
Other   |            | 0.06613    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331878.0 ave      331878 max      331878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331878
Ave neighs/atom = 165.93900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.903693660956, Press = 0.470427908369767
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8012.9227   -8012.9227   -8093.2396   -8093.2396    310.83487    310.83487    21618.752    21618.752    -434.6437    -434.6437 
   43000   -8016.1419   -8016.1419   -8095.0845   -8095.0845    305.51581    305.51581    21645.904    21645.904   -1728.0599   -1728.0599 
Loop time of 33.708 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.563 ns/day, 9.363 hours/ns, 29.667 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    | 33.125     | 33.125     | 33.125     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12899    | 0.12899    | 0.12899    |   0.0 |  0.38
Output  | 0.00023427 | 0.00023427 | 0.00023427 |   0.0 |  0.00
Modify  | 0.38818    | 0.38818    | 0.38818    |   0.0 |  1.15
Other   |            | 0.06563    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331528.0 ave      331528 max      331528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331528
Ave neighs/atom = 165.76400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.904586839771, Press = -0.177098292394191
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8016.1419   -8016.1419   -8095.0845   -8095.0845    305.51581    305.51581    21645.904    21645.904   -1728.0599   -1728.0599 
   44000   -8009.6765   -8009.6765   -8092.6213   -8092.6213    321.00513    321.00513    21588.836    21588.836    2517.3095    2517.3095 
Loop time of 32.7776 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.105 hours/ns, 30.509 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    | 32.201     | 32.201     | 32.201     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.128      | 0.128      | 0.128      |   0.0 |  0.39
Output  | 0.00021778 | 0.00021778 | 0.00021778 |   0.0 |  0.00
Modify  | 0.3831     | 0.3831     | 0.3831     |   0.0 |  1.17
Other   |            | 0.06544    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331170.0 ave      331170 max      331170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331170
Ave neighs/atom = 165.58500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.946883639342, Press = -1.16667698113702
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8009.6765   -8009.6765   -8092.6213   -8092.6213    321.00513    321.00513    21588.836    21588.836    2517.3095    2517.3095 
   45000   -8015.2609   -8015.2609   -8095.2521   -8095.2521    309.57432    309.57432    21609.394    21609.394   -1600.4359   -1600.4359 
Loop time of 32.979 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.620 ns/day, 9.161 hours/ns, 30.322 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    | 32.405     | 32.405     | 32.405     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12796    | 0.12796    | 0.12796    |   0.0 |  0.39
Output  | 0.0001517  | 0.0001517  | 0.0001517  |   0.0 |  0.00
Modify  | 0.38103    | 0.38103    | 0.38103    |   0.0 |  1.16
Other   |            | 0.06532    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332154.0 ave      332154 max      332154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332154
Ave neighs/atom = 166.07700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.978696315644, Press = -1.03533612810088
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8015.2609   -8015.2609   -8095.2521   -8095.2521    309.57432    309.57432    21609.394    21609.394   -1600.4359   -1600.4359 
   46000     -8012.98     -8012.98    -8094.162    -8094.162    314.18253    314.18253    21600.437    21600.437    496.48122    496.48122 
Loop time of 32.6374 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.647 ns/day, 9.066 hours/ns, 30.640 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    | 32.066     | 32.066     | 32.066     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12758    | 0.12758    | 0.12758    |   0.0 |  0.39
Output  | 0.00015135 | 0.00015135 | 0.00015135 |   0.0 |  0.00
Modify  | 0.37767    | 0.37767    | 0.37767    |   0.0 |  1.16
Other   |            | 0.06593    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5455.00 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331740.0 ave      331740 max      331740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331740
Ave neighs/atom = 165.87000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.979329839076, Press = 0.173328604590105
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000     -8012.98     -8012.98    -8094.162    -8094.162    314.18253    314.18253    21600.437    21600.437    496.48122    496.48122 
   47000   -8014.8573   -8014.8573   -8095.7078   -8095.7078    312.89955    312.89955    21649.182    21649.182   -2466.6746   -2466.6746 
Loop time of 32.8339 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.631 ns/day, 9.121 hours/ns, 30.456 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    | 32.268     | 32.268     | 32.268     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12701    | 0.12701    | 0.12701    |   0.0 |  0.39
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.37457    | 0.37457    | 0.37457    |   0.0 |  1.14
Other   |            | 0.06457    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332096.0 ave      332096 max      332096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332096
Ave neighs/atom = 166.04800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.909181343252, Press = -0.330139664627356
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8014.8573   -8014.8573   -8095.7078   -8095.7078    312.89955    312.89955    21649.182    21649.182   -2466.6746   -2466.6746 
   48000   -8013.8727   -8013.8727     -8096.17     -8096.17    318.49918    318.49918    21610.899    21610.899    11.050539    11.050539 
Loop time of 32.207 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.683 ns/day, 8.946 hours/ns, 31.049 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    | 31.643     | 31.643     | 31.643     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12544    | 0.12544    | 0.12544    |   0.0 |  0.39
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.37344    | 0.37344    | 0.37344    |   0.0 |  1.16
Other   |            | 0.06516    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331048.0 ave      331048 max      331048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331048
Ave neighs/atom = 165.52400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.879891515552, Press = -2.0803260740957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8013.8727   -8013.8727     -8096.17     -8096.17    318.49918    318.49918    21610.899    21610.899    11.050539    11.050539 
   49000   -8016.1918   -8016.1918   -8097.3062   -8097.3062    313.92092    313.92092    21608.289    21608.289   -575.17814   -575.17814 
Loop time of 33.5469 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.575 ns/day, 9.319 hours/ns, 29.809 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    | 32.965     | 32.965     | 32.965     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12946    | 0.12946    | 0.12946    |   0.0 |  0.39
Output  | 0.00015762 | 0.00015762 | 0.00015762 |   0.0 |  0.00
Modify  | 0.38566    | 0.38566    | 0.38566    |   0.0 |  1.15
Other   |            | 0.06626    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331600.0 ave      331600 max      331600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331600
Ave neighs/atom = 165.80000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.878353204298, Press = 0.914801282878337
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8016.1918   -8016.1918   -8097.3062   -8097.3062    313.92092    313.92092    21608.289    21608.289   -575.17814   -575.17814 
   50000   -8012.9317   -8012.9317   -8093.0337   -8093.0337    310.00292    310.00292    21658.455    21658.455   -2344.5154   -2344.5154 
Loop time of 32.8156 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.115 hours/ns, 30.473 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    | 32.244     | 32.244     | 32.244     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12727    | 0.12727    | 0.12727    |   0.0 |  0.39
Output  | 0.00015453 | 0.00015453 | 0.00015453 |   0.0 |  0.00
Modify  | 0.37853    | 0.37853    | 0.37853    |   0.0 |  1.15
Other   |            | 0.06572    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331860.0 ave      331860 max      331860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331860
Ave neighs/atom = 165.93000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.826072687449, Press = 0.455686674675315
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8012.9317   -8012.9317   -8093.0337   -8093.0337    310.00292    310.00292    21658.455    21658.455   -2344.5154   -2344.5154 
   51000   -8017.7255   -8017.7255   -8096.5251   -8096.5251    304.96251    304.96251    21586.469    21586.469     667.0752     667.0752 
Loop time of 32.3476 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.985 hours/ns, 30.914 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.778     | 31.778     | 31.778     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12754    | 0.12754    | 0.12754    |   0.0 |  0.39
Output  | 0.00015322 | 0.00015322 | 0.00015322 |   0.0 |  0.00
Modify  | 0.37684    | 0.37684    | 0.37684    |   0.0 |  1.16
Other   |            | 0.06507    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330848.0 ave      330848 max      330848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330848
Ave neighs/atom = 165.42400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.792370672774, Press = 1.15901198852506
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8017.7255   -8017.7255   -8096.5251   -8096.5251    304.96251    304.96251    21586.469    21586.469     667.0752     667.0752 
   52000   -8014.1431   -8014.1431   -8095.6304   -8095.6304    315.36421    315.36421    21554.873    21554.873    4038.8528    4038.8528 
Loop time of 33.8062 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.556 ns/day, 9.391 hours/ns, 29.580 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    | 33.214     | 33.214     | 33.214     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13133    | 0.13133    | 0.13133    |   0.0 |  0.39
Output  | 0.00015583 | 0.00015583 | 0.00015583 |   0.0 |  0.00
Modify  | 0.39473    | 0.39473    | 0.39473    |   0.0 |  1.17
Other   |            | 0.06633    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331728.0 ave      331728 max      331728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331728
Ave neighs/atom = 165.86400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.749038859188, Press = 0.856950029501381
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8014.1431   -8014.1431   -8095.6304   -8095.6304    315.36421    315.36421    21554.873    21554.873    4038.8528    4038.8528 
   53000    -8014.218    -8014.218   -8097.3483   -8097.3483     321.7226     321.7226    21619.308    21619.308   -936.03209   -936.03209 
Loop time of 32.1477 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.688 ns/day, 8.930 hours/ns, 31.106 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    | 31.586     | 31.586     | 31.586     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12562    | 0.12562    | 0.12562    |   0.0 |  0.39
Output  | 0.00015229 | 0.00015229 | 0.00015229 |   0.0 |  0.00
Modify  | 0.37046    | 0.37046    | 0.37046    |   0.0 |  1.15
Other   |            | 0.06507    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332794.0 ave      332794 max      332794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332794
Ave neighs/atom = 166.39700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.741992937603, Press = 0.00741229902125975
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000    -8014.218    -8014.218   -8097.3483   -8097.3483     321.7226     321.7226    21619.308    21619.308   -936.03209   -936.03209 
   54000   -8012.3596   -8012.3596   -8094.1743   -8094.1743    316.63128    316.63128    21610.538    21610.538    607.40271    607.40271 
Loop time of 32.7832 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.106 hours/ns, 30.503 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    | 32.213     | 32.213     | 32.213     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12655    | 0.12655    | 0.12655    |   0.0 |  0.39
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.37763    | 0.37763    | 0.37763    |   0.0 |  1.15
Other   |            | 0.06595    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331320.0 ave      331320 max      331320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331320
Ave neighs/atom = 165.66000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.787446683349, Press = -2.2308674026245
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8012.3596   -8012.3596   -8094.1743   -8094.1743    316.63128    316.63128    21610.538    21610.538    607.40271    607.40271 
   55000    -8017.454    -8017.454   -8096.9501   -8096.9501     307.6582     307.6582    21554.934    21554.934    2628.0441    2628.0441 
Loop time of 32.5916 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.651 ns/day, 9.053 hours/ns, 30.683 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    | 32.02      | 32.02      | 32.02      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12689    | 0.12689    | 0.12689    |   0.0 |  0.39
Output  | 0.00015102 | 0.00015102 | 0.00015102 |   0.0 |  0.00
Modify  | 0.37903    | 0.37903    | 0.37903    |   0.0 |  1.16
Other   |            | 0.06592    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331480.0 ave      331480 max      331480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331480
Ave neighs/atom = 165.74000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.767625934912, Press = 0.424909840194835
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000    -8017.454    -8017.454   -8096.9501   -8096.9501     307.6582     307.6582    21554.934    21554.934    2628.0441    2628.0441 
   56000   -8014.0212   -8014.0212   -8095.1933   -8095.1933    314.14446    314.14446    21666.037    21666.037   -4151.9011   -4151.9011 
Loop time of 32.1735 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.685 ns/day, 8.937 hours/ns, 31.082 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    | 31.612     | 31.612     | 31.612     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12544    | 0.12544    | 0.12544    |   0.0 |  0.39
Output  | 0.00019696 | 0.00019696 | 0.00019696 |   0.0 |  0.00
Modify  | 0.37017    | 0.37017    | 0.37017    |   0.0 |  1.15
Other   |            | 0.06548    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5457.00 ave        5457 max        5457 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332742.0 ave      332742 max      332742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332742
Ave neighs/atom = 166.37100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.759988878444, Press = -0.384282271176175
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -8014.0212   -8014.0212   -8095.1933   -8095.1933    314.14446    314.14446    21666.037    21666.037   -4151.9011   -4151.9011 
   57000   -8010.5352   -8010.5352   -8093.0831   -8093.0831    319.46916    319.46916    21644.432    21644.432   -1619.6248   -1619.6248 
Loop time of 32.2091 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.682 ns/day, 8.947 hours/ns, 31.047 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    | 31.646     | 31.646     | 31.646     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12552    | 0.12552    | 0.12552    |   0.0 |  0.39
Output  | 0.00020243 | 0.00020243 | 0.00020243 |   0.0 |  0.00
Modify  | 0.3724     | 0.3724     | 0.3724     |   0.0 |  1.16
Other   |            | 0.06543    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331052.0 ave      331052 max      331052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331052
Ave neighs/atom = 165.52600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.753678408239, Press = 0.373342267322929
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8010.5352   -8010.5352   -8093.0831   -8093.0831    319.46916    319.46916    21644.432    21644.432   -1619.6248   -1619.6248 
   58000   -8015.1795   -8015.1795   -8096.4357   -8096.4357    314.46976    314.46976    21650.586    21650.586   -3740.2128   -3740.2128 
Loop time of 32.3399 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.983 hours/ns, 30.922 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    | 31.774     | 31.774     | 31.774     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12547    | 0.12547    | 0.12547    |   0.0 |  0.39
Output  | 0.0001487  | 0.0001487  | 0.0001487  |   0.0 |  0.00
Modify  | 0.37448    | 0.37448    | 0.37448    |   0.0 |  1.16
Other   |            | 0.06542    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331250.0 ave      331250 max      331250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331250
Ave neighs/atom = 165.62500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.769846883605, Press = 0.650235108209195
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -8015.1795   -8015.1795   -8096.4357   -8096.4357    314.46976    314.46976    21650.586    21650.586   -3740.2128   -3740.2128 
   59000   -8011.5095   -8011.5095   -8092.5629   -8092.5629    313.68495    313.68495    21612.009    21612.009    1035.2579    1035.2579 
Loop time of 32.6181 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.649 ns/day, 9.061 hours/ns, 30.658 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    | 32.046     | 32.046     | 32.046     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12744    | 0.12744    | 0.12744    |   0.0 |  0.39
Output  | 0.0001958  | 0.0001958  | 0.0001958  |   0.0 |  0.00
Modify  | 0.37934    | 0.37934    | 0.37934    |   0.0 |  1.16
Other   |            | 0.06542    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330978.0 ave      330978 max      330978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330978
Ave neighs/atom = 165.48900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.773837627786, Press = 0.313951542241704
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -8011.5095   -8011.5095   -8092.5629   -8092.5629    313.68495    313.68495    21612.009    21612.009    1035.2579    1035.2579 
   60000   -8012.2494   -8012.2494   -8091.8795   -8091.8795    308.17691    308.17691    21603.245    21603.245    1889.2626    1889.2626 
Loop time of 33.5975 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.572 ns/day, 9.333 hours/ns, 29.764 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    | 33.013     | 33.013     | 33.013     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12989    | 0.12989    | 0.12989    |   0.0 |  0.39
Output  | 0.00019471 | 0.00019471 | 0.00019471 |   0.0 |  0.00
Modify  | 0.38903    | 0.38903    | 0.38903    |   0.0 |  1.16
Other   |            | 0.06559    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332298.0 ave      332298 max      332298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332298
Ave neighs/atom = 166.14900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.759693734594, Press = 1.08146702445568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8012.2494   -8012.2494   -8091.8795   -8091.8795    308.17691    308.17691    21603.245    21603.245    1889.2626    1889.2626 
   61000   -8015.7461   -8015.7461   -8097.2374   -8097.2374    315.37971    315.37971    21609.548    21609.548   -279.24327   -279.24327 
Loop time of 32.7674 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.102 hours/ns, 30.518 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    | 32.195     | 32.195     | 32.195     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12728    | 0.12728    | 0.12728    |   0.0 |  0.39
Output  | 0.00015499 | 0.00015499 | 0.00015499 |   0.0 |  0.00
Modify  | 0.3794     | 0.3794     | 0.3794     |   0.0 |  1.16
Other   |            | 0.06524    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331418.0 ave      331418 max      331418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331418
Ave neighs/atom = 165.70900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.792828483108, Press = -0.394027336677594
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8015.7461   -8015.7461   -8097.2374   -8097.2374    315.37971    315.37971    21609.548    21609.548   -279.24327   -279.24327 
   62000   -8016.4025   -8016.4025   -8096.6089   -8096.6089    310.40708    310.40708    21595.148    21595.148    758.44535    758.44535 
Loop time of 31.7828 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.829 hours/ns, 31.464 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    | 31.227     | 31.227     | 31.227     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12521    | 0.12521    | 0.12521    |   0.0 |  0.39
Output  | 0.00015328 | 0.00015328 | 0.00015328 |   0.0 |  0.00
Modify  | 0.36528    | 0.36528    | 0.36528    |   0.0 |  1.15
Other   |            | 0.06541    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5458.00 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331788.0 ave      331788 max      331788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331788
Ave neighs/atom = 165.89400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.796358276812, Press = 1.14664109801678
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -8016.4025   -8016.4025   -8096.6089   -8096.6089    310.40708    310.40708    21595.148    21595.148    758.44535    758.44535 
   63000   -8014.0238   -8014.0238   -8094.9957   -8094.9957    313.36957    313.36957    21589.281    21589.281    930.57821    930.57821 
Loop time of 33.0257 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.616 ns/day, 9.174 hours/ns, 30.279 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    | 32.45      | 32.45      | 32.45      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1287     | 0.1287     | 0.1287     |   0.0 |  0.39
Output  | 0.00015481 | 0.00015481 | 0.00015481 |   0.0 |  0.00
Modify  | 0.38104    | 0.38104    | 0.38104    |   0.0 |  1.15
Other   |            | 0.06583    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5454.00 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331984.0 ave      331984 max      331984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331984
Ave neighs/atom = 165.99200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.79379390728, Press = -0.125325512314086
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -8014.0238   -8014.0238   -8094.9957   -8094.9957    313.36957    313.36957    21589.281    21589.281    930.57821    930.57821 
   64000   -8018.0383   -8018.0383   -8097.8959   -8097.8959    309.05692    309.05692    21595.754    21595.754    389.58863    389.58863 
Loop time of 32.1546 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.687 ns/day, 8.932 hours/ns, 31.100 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    | 31.594     | 31.594     | 31.594     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12608    | 0.12608    | 0.12608    |   0.0 |  0.39
Output  | 0.00019216 | 0.00019216 | 0.00019216 |   0.0 |  0.00
Modify  | 0.36937    | 0.36937    | 0.36937    |   0.0 |  1.15
Other   |            | 0.0652     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332052.0 ave      332052 max      332052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332052
Ave neighs/atom = 166.02600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.74506534285, Press = 0.738042740603197
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -8018.0383   -8018.0383   -8097.8959   -8097.8959    309.05692    309.05692    21595.754    21595.754    389.58863    389.58863 
   65000   -8015.3759   -8015.3759   -8095.0758   -8095.0758    308.44695    308.44695    21579.033    21579.033    989.45648    989.45648 
Loop time of 31.7868 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.830 hours/ns, 31.460 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    | 31.23      | 31.23      | 31.23      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12416    | 0.12416    | 0.12416    |   0.0 |  0.39
Output  | 0.00019281 | 0.00019281 | 0.00019281 |   0.0 |  0.00
Modify  | 0.36721    | 0.36721    | 0.36721    |   0.0 |  1.16
Other   |            | 0.06494    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331860.0 ave      331860 max      331860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331860
Ave neighs/atom = 165.93000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.718468167485, Press = -1.1420794572583
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -8015.3759   -8015.3759   -8095.0758   -8095.0758    308.44695    308.44695    21579.033    21579.033    989.45648    989.45648 
   66000   -8013.3398   -8013.3398   -8096.4858   -8096.4858    321.78352    321.78352    21577.458    21577.458    1789.1871    1789.1871 
Loop time of 31.7896 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.830 hours/ns, 31.457 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    | 31.232     | 31.232     | 31.232     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12451    | 0.12451    | 0.12451    |   0.0 |  0.39
Output  | 0.00014947 | 0.00014947 | 0.00014947 |   0.0 |  0.00
Modify  | 0.36776    | 0.36776    | 0.36776    |   0.0 |  1.16
Other   |            | 0.06545    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332340.0 ave      332340 max      332340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332340
Ave neighs/atom = 166.17000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.667668221624, Press = -1.17546109249102
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -8013.3398   -8013.3398   -8096.4858   -8096.4858    321.78352    321.78352    21577.458    21577.458    1789.1871    1789.1871 
   67000   -8017.7361   -8017.7361   -8097.6137   -8097.6137    309.13459    309.13459    21581.884    21581.884    1820.5501    1820.5501 
Loop time of 31.774 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.719 ns/day, 8.826 hours/ns, 31.472 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    | 31.213     | 31.213     | 31.213     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12539    | 0.12539    | 0.12539    |   0.0 |  0.39
Output  | 0.00015938 | 0.00015938 | 0.00015938 |   0.0 |  0.00
Modify  | 0.36996    | 0.36996    | 0.36996    |   0.0 |  1.16
Other   |            | 0.06543    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332382.0 ave      332382 max      332382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332382
Ave neighs/atom = 166.19100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.641603602808, Press = 0.358098663030236
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -8017.7361   -8017.7361   -8097.6137   -8097.6137    309.13459    309.13459    21581.884    21581.884    1820.5501    1820.5501 
   68000   -8014.1585   -8014.1585   -8095.4767   -8095.4767     314.7097     314.7097    21591.135    21591.135    1134.8119    1134.8119 
Loop time of 32.3034 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.973 hours/ns, 30.956 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    | 31.739     | 31.739     | 31.739     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12622    | 0.12622    | 0.12622    |   0.0 |  0.39
Output  | 0.0001967  | 0.0001967  | 0.0001967  |   0.0 |  0.00
Modify  | 0.37271    | 0.37271    | 0.37271    |   0.0 |  1.15
Other   |            | 0.0653     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332350.0 ave      332350 max      332350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332350
Ave neighs/atom = 166.17500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.623837131116, Press = 1.10136664111561
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -8014.1585   -8014.1585   -8095.4767   -8095.4767     314.7097     314.7097    21591.135    21591.135    1134.8119    1134.8119 
   69000   -8019.3367   -8019.3367   -8097.5163   -8097.5163    302.56328    302.56328    21610.535    21610.535    -1625.475    -1625.475 
Loop time of 31.7836 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.829 hours/ns, 31.463 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.224     | 31.224     | 31.224     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12496    | 0.12496    | 0.12496    |   0.0 |  0.39
Output  | 0.00015797 | 0.00015797 | 0.00015797 |   0.0 |  0.00
Modify  | 0.36874    | 0.36874    | 0.36874    |   0.0 |  1.16
Other   |            | 0.0653     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331698.0 ave      331698 max      331698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331698
Ave neighs/atom = 165.84900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.583065739147, Press = -0.194410859279769
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -8019.3367   -8019.3367   -8097.5163   -8097.5163    302.56328    302.56328    21610.535    21610.535    -1625.475    -1625.475 
   70000   -8014.7657   -8014.7657   -8097.7572   -8097.7572    321.18576    321.18576     21605.69     21605.69   -1639.0151   -1639.0151 
Loop time of 31.9336 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.706 ns/day, 8.870 hours/ns, 31.315 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    | 31.371     | 31.371     | 31.371     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12579    | 0.12579    | 0.12579    |   0.0 |  0.39
Output  | 0.00015564 | 0.00015564 | 0.00015564 |   0.0 |  0.00
Modify  | 0.37155    | 0.37155    | 0.37155    |   0.0 |  1.16
Other   |            | 0.06518    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331882.0 ave      331882 max      331882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331882
Ave neighs/atom = 165.94100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.571902084568, Press = 1.5004770473731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -8014.7657   -8014.7657   -8097.7572   -8097.7572    321.18576    321.18576     21605.69     21605.69   -1639.0151   -1639.0151 
   71000    -8013.325    -8013.325   -8095.8703   -8095.8703    319.45913    319.45913     21658.37     21658.37   -3537.6897   -3537.6897 
Loop time of 31.5318 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.759 hours/ns, 31.714 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    | 30.977     | 30.977     | 30.977     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12401    | 0.12401    | 0.12401    |   0.0 |  0.39
Output  | 0.0001565  | 0.0001565  | 0.0001565  |   0.0 |  0.00
Modify  | 0.36465    | 0.36465    | 0.36465    |   0.0 |  1.16
Other   |            | 0.06549    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331912.0 ave      331912 max      331912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331912
Ave neighs/atom = 165.95600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.529782381004, Press = -0.88048451818037
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000    -8013.325    -8013.325   -8095.8703   -8095.8703    319.45913    319.45913     21658.37     21658.37   -3537.6897   -3537.6897 
   72000   -8019.2521   -8019.2521   -8098.2346   -8098.2346    305.67053    305.67053    21576.693    21576.693   -792.67781   -792.67781 
Loop time of 31.6347 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.731 ns/day, 8.787 hours/ns, 31.611 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    | 31.076     | 31.076     | 31.076     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12496    | 0.12496    | 0.12496    |   0.0 |  0.39
Output  | 0.00015501 | 0.00015501 | 0.00015501 |   0.0 |  0.00
Modify  | 0.36839    | 0.36839    | 0.36839    |   0.0 |  1.16
Other   |            | 0.06483    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330794.0 ave      330794 max      330794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330794
Ave neighs/atom = 165.39700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.493365077983, Press = -1.8714969909652
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -8019.2521   -8019.2521   -8098.2346   -8098.2346    305.67053    305.67053    21576.693    21576.693   -792.67781   -792.67781 
   73000   -8012.2605   -8012.2605   -8093.7175   -8093.7175     315.2468     315.2468    21647.268    21647.268   -1177.2489   -1177.2489 
Loop time of 31.8075 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.835 hours/ns, 31.439 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    | 31.248     | 31.248     | 31.248     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12442    | 0.12442    | 0.12442    |   0.0 |  0.39
Output  | 0.00015541 | 0.00015541 | 0.00015541 |   0.0 |  0.00
Modify  | 0.36911    | 0.36911    | 0.36911    |   0.0 |  1.16
Other   |            | 0.06562    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332298.0 ave      332298 max      332298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332298
Ave neighs/atom = 166.14900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.462342699899, Press = 0.597878919865181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -8012.2605   -8012.2605   -8093.7175   -8093.7175     315.2468     315.2468    21647.268    21647.268   -1177.2489   -1177.2489 
   74000    -8014.127    -8014.127   -8094.1239   -8094.1239    309.59619    309.59619    21617.354    21617.354   -559.08626   -559.08626 
Loop time of 32.4538 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.662 ns/day, 9.015 hours/ns, 30.813 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    | 31.886     | 31.886     | 31.886     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12685    | 0.12685    | 0.12685    |   0.0 |  0.39
Output  | 0.0001613  | 0.0001613  | 0.0001613  |   0.0 |  0.00
Modify  | 0.37524    | 0.37524    | 0.37524    |   0.0 |  1.16
Other   |            | 0.0655     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5418.00 ave        5418 max        5418 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331106.0 ave      331106 max      331106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331106
Ave neighs/atom = 165.55300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.452964494515, Press = -0.166099098508059
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000    -8014.127    -8014.127   -8094.1239   -8094.1239    309.59619    309.59619    21617.354    21617.354   -559.08626   -559.08626 
   75000   -8016.5334   -8016.5334   -8095.2423   -8095.2423    304.61175    304.61175    21601.576    21601.576   -38.970374   -38.970374 
Loop time of 32.5226 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.657 ns/day, 9.034 hours/ns, 30.748 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    | 31.955     | 31.955     | 31.955     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12616    | 0.12616    | 0.12616    |   0.0 |  0.39
Output  | 0.0001572  | 0.0001572  | 0.0001572  |   0.0 |  0.00
Modify  | 0.37509    | 0.37509    | 0.37509    |   0.0 |  1.15
Other   |            | 0.06598    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5447.00 ave        5447 max        5447 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331626.0 ave      331626 max      331626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331626
Ave neighs/atom = 165.81300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.49423112327, Press = -0.385859906701932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -8016.5334   -8016.5334   -8095.2423   -8095.2423    304.61175    304.61175    21601.576    21601.576   -38.970374   -38.970374 
   76000   -8008.9861   -8008.9861   -8092.1259   -8092.1259    321.75955    321.75955    21624.746    21624.746    843.53731    843.53731 
Loop time of 32.3842 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.668 ns/day, 8.996 hours/ns, 30.879 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    | 31.816     | 31.816     | 31.816     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12672    | 0.12672    | 0.12672    |   0.0 |  0.39
Output  | 0.00016573 | 0.00016573 | 0.00016573 |   0.0 |  0.00
Modify  | 0.37574    | 0.37574    | 0.37574    |   0.0 |  1.16
Other   |            | 0.06549    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5461.00 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331950.0 ave      331950 max      331950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331950
Ave neighs/atom = 165.97500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.50310187744, Press = -1.50919762945815
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -8008.9861   -8008.9861   -8092.1259   -8092.1259    321.75955    321.75955    21624.746    21624.746    843.53731    843.53731 
   77000   -8011.8198   -8011.8198   -8093.8904   -8093.8904    317.62186    317.62186     21611.54     21611.54    473.45502    473.45502 
Loop time of 32.7841 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.635 ns/day, 9.107 hours/ns, 30.503 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    | 32.208     | 32.208     | 32.208     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12811    | 0.12811    | 0.12811    |   0.0 |  0.39
Output  | 0.00015505 | 0.00015505 | 0.00015505 |   0.0 |  0.00
Modify  | 0.38138    | 0.38138    | 0.38138    |   0.0 |  1.16
Other   |            | 0.06638    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5452.00 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331330.0 ave      331330 max      331330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331330
Ave neighs/atom = 165.66500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.514111377812, Press = -0.469284787607025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -8011.8198   -8011.8198   -8093.8904   -8093.8904    317.62186    317.62186     21611.54     21611.54    473.45502    473.45502 
   78000   -8015.5139   -8015.5139   -8095.7622   -8095.7622    310.56906    310.56906    21540.591    21540.591    4102.9143    4102.9143 
Loop time of 32.6991 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.642 ns/day, 9.083 hours/ns, 30.582 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    | 32.128     | 32.128     | 32.128     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12633    | 0.12633    | 0.12633    |   0.0 |  0.39
Output  | 0.00024658 | 0.00024658 | 0.00024658 |   0.0 |  0.00
Modify  | 0.37888    | 0.37888    | 0.37888    |   0.0 |  1.16
Other   |            | 0.06573    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331626.0 ave      331626 max      331626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331626
Ave neighs/atom = 165.81300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.503437589385, Press = 0.395964431601458
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -8015.5139   -8015.5139   -8095.7622   -8095.7622    310.56906    310.56906    21540.591    21540.591    4102.9143    4102.9143 
   79000   -8015.3771   -8015.3771   -8095.8012   -8095.8012    311.24982    311.24982    21640.814    21640.814   -2685.2602   -2685.2602 
Loop time of 32.9564 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.155 hours/ns, 30.343 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    | 32.38      | 32.38      | 32.38      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12759    | 0.12759    | 0.12759    |   0.0 |  0.39
Output  | 0.00019396 | 0.00019396 | 0.00019396 |   0.0 |  0.00
Modify  | 0.38165    | 0.38165    | 0.38165    |   0.0 |  1.16
Other   |            | 0.06675    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5445.00 ave        5445 max        5445 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332762.0 ave      332762 max      332762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332762
Ave neighs/atom = 166.38100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.489037141418, Press = 0.496495392939558
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -8015.3771   -8015.3771   -8095.8012   -8095.8012    311.24982    311.24982    21640.814    21640.814   -2685.2602   -2685.2602 
   80000   -8011.3141   -8011.3141   -8096.1434   -8096.1434    328.29811    328.29811     21575.43     21575.43    875.00855    875.00855 
Loop time of 32.0467 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.696 ns/day, 8.902 hours/ns, 31.204 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    | 31.484     | 31.484     | 31.484     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12487    | 0.12487    | 0.12487    |   0.0 |  0.39
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.37209    | 0.37209    | 0.37209    |   0.0 |  1.16
Other   |            | 0.06595    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331380.0 ave      331380 max      331380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331380
Ave neighs/atom = 165.69000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.478922686962, Press = 0.61851342060737
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -8011.3141   -8011.3141   -8096.1434   -8096.1434    328.29811    328.29811     21575.43     21575.43    875.00855    875.00855 
   81000   -8014.6728   -8014.6728   -8094.5771   -8094.5771    309.23784    309.23784    21586.312    21586.312    1840.1592    1840.1592 
Loop time of 31.6316 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.731 ns/day, 8.787 hours/ns, 31.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    | 31.07      | 31.07      | 31.07      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.125      | 0.125      | 0.125      |   0.0 |  0.40
Output  | 0.00015282 | 0.00015282 | 0.00015282 |   0.0 |  0.00
Modify  | 0.37069    | 0.37069    | 0.37069    |   0.0 |  1.17
Other   |            | 0.06618    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332372.0 ave      332372 max      332372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332372
Ave neighs/atom = 166.18600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.484839516115, Press = -0.171209192666314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -8014.6728   -8014.6728   -8094.5771   -8094.5771    309.23784    309.23784    21586.312    21586.312    1840.1592    1840.1592 
   82000   -8016.3705   -8016.3705   -8096.4577   -8096.4577    309.94556    309.94556    21616.739    21616.739   -1348.0373   -1348.0373 
Loop time of 31.8973 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.709 ns/day, 8.860 hours/ns, 31.351 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    | 31.336     | 31.336     | 31.336     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12538    | 0.12538    | 0.12538    |   0.0 |  0.39
Output  | 0.0004557  | 0.0004557  | 0.0004557  |   0.0 |  0.00
Modify  | 0.37042    | 0.37042    | 0.37042    |   0.0 |  1.16
Other   |            | 0.06522    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332310.0 ave      332310 max      332310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332310
Ave neighs/atom = 166.15500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.518632090513, Press = 1.00777889003016
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -8016.3705   -8016.3705   -8096.4577   -8096.4577    309.94556    309.94556    21616.739    21616.739   -1348.0373   -1348.0373 
   83000    -8013.853    -8013.853   -8096.7666   -8096.7666    320.88441    320.88441      21593.5      21593.5     -265.435     -265.435 
Loop time of 31.4704 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.742 hours/ns, 31.776 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    | 30.916     | 30.916     | 30.916     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12439    | 0.12439    | 0.12439    |   0.0 |  0.40
Output  | 0.00015787 | 0.00015787 | 0.00015787 |   0.0 |  0.00
Modify  | 0.36501    | 0.36501    | 0.36501    |   0.0 |  1.16
Other   |            | 0.0653     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331504.0 ave      331504 max      331504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331504
Ave neighs/atom = 165.75200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.511905329756, Press = -1.03809424330523
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000    -8013.853    -8013.853   -8096.7666   -8096.7666    320.88441    320.88441      21593.5      21593.5     -265.435     -265.435 
   84000   -8013.7501   -8013.7501   -8095.9524   -8095.9524    318.13155    318.13155    21599.951    21599.951    374.36793    374.36793 
Loop time of 32.4654 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.661 ns/day, 9.018 hours/ns, 30.802 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    | 31.898     | 31.898     | 31.898     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12649    | 0.12649    | 0.12649    |   0.0 |  0.39
Output  | 0.00023776 | 0.00023776 | 0.00023776 |   0.0 |  0.00
Modify  | 0.37564    | 0.37564    | 0.37564    |   0.0 |  1.16
Other   |            | 0.06533    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5442.00 ave        5442 max        5442 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331876.0 ave      331876 max      331876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331876
Ave neighs/atom = 165.93800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.521257703913, Press = -0.0085148446231387
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -8013.7501   -8013.7501   -8095.9524   -8095.9524    318.13155    318.13155    21599.951    21599.951    374.36793    374.36793 
   85000   -8016.1983   -8016.1983   -8095.7212   -8095.7212    307.76182    307.76182    21633.128    21633.128   -1084.4537   -1084.4537 
Loop time of 32.1907 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.684 ns/day, 8.942 hours/ns, 31.065 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    | 31.625     | 31.625     | 31.625     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12729    | 0.12729    | 0.12729    |   0.0 |  0.40
Output  | 0.00015713 | 0.00015713 | 0.00015713 |   0.0 |  0.00
Modify  | 0.37318    | 0.37318    | 0.37318    |   0.0 |  1.16
Other   |            | 0.0654     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331830.0 ave      331830 max      331830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331830
Ave neighs/atom = 165.91500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.534135155913, Press = 0.0887266504718699
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -8016.1983   -8016.1983   -8095.7212   -8095.7212    307.76182    307.76182    21633.128    21633.128   -1084.4537   -1084.4537 
   86000   -8012.0195   -8012.0195   -8096.3136   -8096.3136    326.22707    326.22707    21608.149    21608.149    192.70779    192.70779 
Loop time of 32.6507 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.646 ns/day, 9.070 hours/ns, 30.627 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    | 32.076     | 32.076     | 32.076     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12811    | 0.12811    | 0.12811    |   0.0 |  0.39
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.38001    | 0.38001    | 0.38001    |   0.0 |  1.16
Other   |            | 0.06595    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331198.0 ave      331198 max      331198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331198
Ave neighs/atom = 165.59900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.537700680387, Press = -0.432039612973922
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -8012.0195   -8012.0195   -8096.3136   -8096.3136    326.22707    326.22707    21608.149    21608.149    192.70779    192.70779 
   87000   -8010.5649   -8010.5649   -8093.3746   -8093.3746    320.48193    320.48193    21621.474    21621.474   -266.40375   -266.40375 
Loop time of 32.1397 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.688 ns/day, 8.928 hours/ns, 31.114 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    | 31.573     | 31.573     | 31.573     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1262     | 0.1262     | 0.1262     |   0.0 |  0.39
Output  | 0.00018754 | 0.00018754 | 0.00018754 |   0.0 |  0.00
Modify  | 0.37382    | 0.37382    | 0.37382    |   0.0 |  1.16
Other   |            | 0.0661     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331692.0 ave      331692 max      331692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331692
Ave neighs/atom = 165.84600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.537851404442, Press = 1.06246872491178
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -8010.5649   -8010.5649   -8093.3746   -8093.3746    320.48193    320.48193    21621.474    21621.474   -266.40375   -266.40375 
   88000   -8015.2718   -8015.2718   -8095.6301   -8095.6301    310.99517    310.99517    21609.947    21609.947    -1565.116    -1565.116 
Loop time of 31.3044 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.760 ns/day, 8.696 hours/ns, 31.944 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    | 30.75      | 30.75      | 30.75      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.39
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.36496    | 0.36496    | 0.36496    |   0.0 |  1.17
Other   |            | 0.0661     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331800.0 ave      331800 max      331800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331800
Ave neighs/atom = 165.90000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.568325433097, Press = 0.707660293572036
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -8015.2718   -8015.2718   -8095.6301   -8095.6301    310.99517    310.99517    21609.947    21609.947    -1565.116    -1565.116 
   89000   -8013.8792   -8013.8792   -8094.2756   -8094.2756    311.14225    311.14225    21608.935    21608.935   -48.249087   -48.249087 
Loop time of 31.8597 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.712 ns/day, 8.850 hours/ns, 31.388 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    | 31.298     | 31.298     | 31.298     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1243     | 0.1243     | 0.1243     |   0.0 |  0.39
Output  | 0.00015381 | 0.00015381 | 0.00015381 |   0.0 |  0.00
Modify  | 0.37134    | 0.37134    | 0.37134    |   0.0 |  1.17
Other   |            | 0.06558    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5460.00 ave        5460 max        5460 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331710.0 ave      331710 max      331710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331710
Ave neighs/atom = 165.85500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.565824291467, Press = -1.13116304374076
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -8013.8792   -8013.8792   -8094.2756   -8094.2756    311.14225    311.14225    21608.935    21608.935   -48.249087   -48.249087 
   90000   -8014.9577   -8014.9577   -8096.0984   -8096.0984    314.02302    314.02302    21596.956    21596.956    327.24779    327.24779 
Loop time of 32.2862 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.676 ns/day, 8.968 hours/ns, 30.973 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    | 31.718     | 31.718     | 31.718     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12643    | 0.12643    | 0.12643    |   0.0 |  0.39
Output  | 0.00015132 | 0.00015132 | 0.00015132 |   0.0 |  0.00
Modify  | 0.37581    | 0.37581    | 0.37581    |   0.0 |  1.16
Other   |            | 0.0654     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331710.0 ave      331710 max      331710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331710
Ave neighs/atom = 165.85500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.531011766011, Press = -0.302258814318872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -8014.9577   -8014.9577   -8096.0984   -8096.0984    314.02302    314.02302    21596.956    21596.956    327.24779    327.24779 
   91000   -8013.4736   -8013.4736   -8092.5934   -8092.5934    306.20166    306.20166    21571.298    21571.298    2970.5495    2970.5495 
Loop time of 31.6007 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.778 hours/ns, 31.645 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    | 31.043     | 31.043     | 31.043     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12436    | 0.12436    | 0.12436    |   0.0 |  0.39
Output  | 0.00019879 | 0.00019879 | 0.00019879 |   0.0 |  0.00
Modify  | 0.36747    | 0.36747    | 0.36747    |   0.0 |  1.16
Other   |            | 0.06587    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332268.0 ave      332268 max      332268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332268
Ave neighs/atom = 166.13400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.52946111317, Press = -0.271909801780981
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -8013.4736   -8013.4736   -8092.5934   -8092.5934    306.20166    306.20166    21571.298    21571.298    2970.5495    2970.5495 
   92000   -8014.3187   -8014.3187   -8094.1018   -8094.1018    308.76876    308.76876    21593.672    21593.672    1613.1531    1613.1531 
Loop time of 31.3012 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.760 ns/day, 8.695 hours/ns, 31.948 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    | 30.749     | 30.749     | 30.749     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12262    | 0.12262    | 0.12262    |   0.0 |  0.39
Output  | 0.00015278 | 0.00015278 | 0.00015278 |   0.0 |  0.00
Modify  | 0.36373    | 0.36373    | 0.36373    |   0.0 |  1.16
Other   |            | 0.06531    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332386.0 ave      332386 max      332386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332386
Ave neighs/atom = 166.19300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.504729536798, Press = 0.0368969048074594
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -8014.3187   -8014.3187   -8094.1018   -8094.1018    308.76876    308.76876    21593.672    21593.672    1613.1531    1613.1531 
   93000   -8014.5581   -8014.5581   -8093.4391   -8093.4391    305.27762    305.27762    21657.907    21657.907   -2739.3928   -2739.3928 
Loop time of 31.8843 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.710 ns/day, 8.857 hours/ns, 31.363 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    | 31.323     | 31.323     | 31.323     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12649    | 0.12649    | 0.12649    |   0.0 |  0.40
Output  | 0.00015542 | 0.00015542 | 0.00015542 |   0.0 |  0.00
Modify  | 0.36936    | 0.36936    | 0.36936    |   0.0 |  1.16
Other   |            | 0.06525    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331926.0 ave      331926 max      331926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331926
Ave neighs/atom = 165.96300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.496164534515, Press = 1.1575718849961
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -8014.5581   -8014.5581   -8093.4391   -8093.4391    305.27762    305.27762    21657.907    21657.907   -2739.3928   -2739.3928 
   94000   -8014.0129   -8014.0129   -8094.2745   -8094.2745    310.62053    310.62053    21610.577    21610.577     174.8023     174.8023 
Loop time of 31.244 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.765 ns/day, 8.679 hours/ns, 32.006 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    | 30.691     | 30.691     | 30.691     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12539    | 0.12539    | 0.12539    |   0.0 |  0.40
Output  | 0.00016946 | 0.00016946 | 0.00016946 |   0.0 |  0.00
Modify  | 0.36234    | 0.36234    | 0.36234    |   0.0 |  1.16
Other   |            | 0.06513    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5450.00 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331200.0 ave      331200 max      331200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331200
Ave neighs/atom = 165.60000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.513766875727, Press = 0.103668845578962
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -8014.0129   -8014.0129   -8094.2745   -8094.2745    310.62053    310.62053    21610.577    21610.577     174.8023     174.8023 
   95000   -8011.9922   -8011.9922   -8095.3651   -8095.3651    322.66171    322.66171     21592.95     21592.95    775.30839    775.30839 
Loop time of 32.5839 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.652 ns/day, 9.051 hours/ns, 30.690 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    | 32.011     | 32.011     | 32.011     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12678    | 0.12678    | 0.12678    |   0.0 |  0.39
Output  | 0.0002003  | 0.0002003  | 0.0002003  |   0.0 |  0.00
Modify  | 0.37958    | 0.37958    | 0.37958    |   0.0 |  1.16
Other   |            | 0.0661     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331890.0 ave      331890 max      331890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331890
Ave neighs/atom = 165.94500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.514245127614, Press = 0.777862420587424
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -8011.9922   -8011.9922   -8095.3651   -8095.3651    322.66171    322.66171     21592.95     21592.95    775.30839    775.30839 
   96000   -8017.2712   -8017.2712   -8095.7083   -8095.7083     303.5596     303.5596    21579.681    21579.681    1462.3048    1462.3048 
Loop time of 31.7165 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.724 ns/day, 8.810 hours/ns, 31.529 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    | 31.156     | 31.156     | 31.156     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12569    | 0.12569    | 0.12569    |   0.0 |  0.40
Output  | 0.00015555 | 0.00015555 | 0.00015555 |   0.0 |  0.00
Modify  | 0.36907    | 0.36907    | 0.36907    |   0.0 |  1.16
Other   |            | 0.06605    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331928.0 ave      331928 max      331928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331928
Ave neighs/atom = 165.96400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.495519465189, Press = -0.251956170729599
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -8017.2712   -8017.2712   -8095.7083   -8095.7083     303.5596     303.5596    21579.681    21579.681    1462.3048    1462.3048 
   97000   -8014.3755   -8014.3755   -8095.5717   -8095.5717    314.23796    314.23796    21591.438    21591.438    1063.0922    1063.0922 
Loop time of 31.9312 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.706 ns/day, 8.870 hours/ns, 31.317 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    | 31.366     | 31.366     | 31.366     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12624    | 0.12624    | 0.12624    |   0.0 |  0.40
Output  | 0.00019311 | 0.00019311 | 0.00019311 |   0.0 |  0.00
Modify  | 0.37297    | 0.37297    | 0.37297    |   0.0 |  1.17
Other   |            | 0.06625    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5443.00 ave        5443 max        5443 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332394.0 ave      332394 max      332394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332394
Ave neighs/atom = 166.19700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.490962016782, Press = 0.413938716787382
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -8014.3755   -8014.3755   -8095.5717   -8095.5717    314.23796    314.23796    21591.438    21591.438    1063.0922    1063.0922 
   98000   -8015.0428   -8015.0428   -8095.6779   -8095.6779    312.06599    312.06599    21627.782    21627.782   -1844.0067   -1844.0067 
Loop time of 31.8437 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.713 ns/day, 8.845 hours/ns, 31.403 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    | 31.281     | 31.281     | 31.281     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12645    | 0.12645    | 0.12645    |   0.0 |  0.40
Output  | 0.00015326 | 0.00015326 | 0.00015326 |   0.0 |  0.00
Modify  | 0.36919    | 0.36919    | 0.36919    |   0.0 |  1.16
Other   |            | 0.06643    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331972.0 ave      331972 max      331972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331972
Ave neighs/atom = 165.98600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.506465914327, Press = 0.565863602852194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -8015.0428   -8015.0428   -8095.6779   -8095.6779    312.06599    312.06599    21627.782    21627.782   -1844.0067   -1844.0067 
   99000    -8015.637    -8015.637   -8095.9471   -8095.9471    310.80821    310.80821    21562.332    21562.332    2719.5428    2719.5428 
Loop time of 30.9722 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.790 ns/day, 8.603 hours/ns, 32.287 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    | 30.423     | 30.423     | 30.423     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12224    | 0.12224    | 0.12224    |   0.0 |  0.39
Output  | 0.00015894 | 0.00015894 | 0.00015894 |   0.0 |  0.00
Modify  | 0.36125    | 0.36125    | 0.36125    |   0.0 |  1.17
Other   |            | 0.06573    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331336.0 ave      331336 max      331336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331336
Ave neighs/atom = 165.66800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.525982288388, Press = 0.836220775737011
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000    -8015.637    -8015.637   -8095.9471   -8095.9471    310.80821    310.80821    21562.332    21562.332    2719.5428    2719.5428 
  100000   -8011.6276   -8011.6276   -8094.9158   -8094.9158    322.33396    322.33396    21631.838    21631.838    -999.1261    -999.1261 
Loop time of 31.7133 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.724 ns/day, 8.809 hours/ns, 31.532 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    | 31.153     | 31.153     | 31.153     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1251     | 0.1251     | 0.1251     |   0.0 |  0.39
Output  | 0.00020369 | 0.00020369 | 0.00020369 |   0.0 |  0.00
Modify  | 0.36918    | 0.36918    | 0.36918    |   0.0 |  1.16
Other   |            | 0.0656     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5453.00 ave        5453 max        5453 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332328.0 ave      332328 max      332328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332328
Ave neighs/atom = 166.16400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.539809771462, Press = 0.206108149296011
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -8011.6276   -8011.6276   -8094.9158   -8094.9158    322.33396    322.33396    21631.838    21631.838    -999.1261    -999.1261 
  101000   -8015.7934   -8015.7934   -8097.2054   -8097.2054    315.07259    315.07259    21555.334    21555.334    2199.6344    2199.6344 
Loop time of 32.7406 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.639 ns/day, 9.095 hours/ns, 30.543 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    | 32.167     | 32.167     | 32.167     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12729    | 0.12729    | 0.12729    |   0.0 |  0.39
Output  | 0.00015642 | 0.00015642 | 0.00015642 |   0.0 |  0.00
Modify  | 0.38104    | 0.38104    | 0.38104    |   0.0 |  1.16
Other   |            | 0.06554    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331502.0 ave      331502 max      331502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331502
Ave neighs/atom = 165.75100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.55667755641, Press = -0.36981489449871
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -8015.7934   -8015.7934   -8097.2054   -8097.2054    315.07259    315.07259    21555.334    21555.334    2199.6344    2199.6344 
  102000   -8016.8649   -8016.8649    -8096.282    -8096.282    307.35224    307.35224    21616.369    21616.369   -646.48133   -646.48133 
Loop time of 32.684 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.643 ns/day, 9.079 hours/ns, 30.596 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    | 32.113     | 32.113     | 32.113     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12665    | 0.12665    | 0.12665    |   0.0 |  0.39
Output  | 0.00020221 | 0.00020221 | 0.00020221 |   0.0 |  0.00
Modify  | 0.37808    | 0.37808    | 0.37808    |   0.0 |  1.16
Other   |            | 0.06583    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332474.0 ave      332474 max      332474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332474
Ave neighs/atom = 166.23700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.551572848155, Press = 0.337704171663274
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -8016.8649   -8016.8649    -8096.282    -8096.282    307.35224    307.35224    21616.369    21616.369   -646.48133   -646.48133 
  103000   -8013.7956   -8013.7956   -8096.7275   -8096.7275    320.95487    320.95487    21582.673    21582.673    1431.5025    1431.5025 
Loop time of 31.721 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.724 ns/day, 8.811 hours/ns, 31.525 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    | 31.16      | 31.16      | 31.16      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12454    | 0.12454    | 0.12454    |   0.0 |  0.39
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.37047    | 0.37047    | 0.37047    |   0.0 |  1.17
Other   |            | 0.06545    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5423.00 ave        5423 max        5423 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331746.0 ave      331746 max      331746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331746
Ave neighs/atom = 165.87300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.54315535897, Press = -0.161483662290782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -8013.7956   -8013.7956   -8096.7275   -8096.7275    320.95487    320.95487    21582.673    21582.673    1431.5025    1431.5025 
  104000   -8015.9703   -8015.9703   -8095.0468   -8095.0468    306.03402    306.03402    21618.439    21618.439    143.68599    143.68599 
Loop time of 31.8005 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.833 hours/ns, 31.446 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    | 31.241     | 31.241     | 31.241     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.40
Output  | 0.00019505 | 0.00019505 | 0.00019505 |   0.0 |  0.00
Modify  | 0.36844    | 0.36844    | 0.36844    |   0.0 |  1.16
Other   |            | 0.06503    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332048.0 ave      332048 max      332048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332048
Ave neighs/atom = 166.02400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.542145110928, Press = -0.131516260556517
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -8015.9703   -8015.9703   -8095.0468   -8095.0468    306.03402    306.03402    21618.439    21618.439    143.68599    143.68599 
  105000   -8013.3379   -8013.3379    -8093.014    -8093.014    308.35472    308.35472    21602.762    21602.762    261.26521    261.26521 
Loop time of 31.6056 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.779 hours/ns, 31.640 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    | 31.048     | 31.048     | 31.048     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12559    | 0.12559    | 0.12559    |   0.0 |  0.40
Output  | 0.0001532  | 0.0001532  | 0.0001532  |   0.0 |  0.00
Modify  | 0.36637    | 0.36637    | 0.36637    |   0.0 |  1.16
Other   |            | 0.06596    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331440.0 ave      331440 max      331440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331440
Ave neighs/atom = 165.72000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.547617903278, Press = -0.843304717634318
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -8013.3379   -8013.3379    -8093.014    -8093.014    308.35472    308.35472    21602.762    21602.762    261.26521    261.26521 
  106000    -8013.606    -8013.606   -8095.5922   -8095.5922    317.29508    317.29508    21603.851    21603.851    1225.7752    1225.7752 
Loop time of 32.7764 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.105 hours/ns, 30.510 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    | 32.2       | 32.2       | 32.2       |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12829    | 0.12829    | 0.12829    |   0.0 |  0.39
Output  | 0.00015476 | 0.00015476 | 0.00015476 |   0.0 |  0.00
Modify  | 0.38176    | 0.38176    | 0.38176    |   0.0 |  1.16
Other   |            | 0.06582    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331960.0 ave      331960 max      331960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331960
Ave neighs/atom = 165.98000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.539051226114, Press = 0.113579330702831
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000    -8013.606    -8013.606   -8095.5922   -8095.5922    317.29508    317.29508    21603.851    21603.851    1225.7752    1225.7752 
  107000   -8013.6348   -8013.6348   -8095.4942   -8095.4942     316.8045     316.8045    21582.456    21582.456    1531.6631    1531.6631 
Loop time of 31.8462 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.713 ns/day, 8.846 hours/ns, 31.401 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    | 31.282     | 31.282     | 31.282     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12599    | 0.12599    | 0.12599    |   0.0 |  0.40
Output  | 0.00020612 | 0.00020612 | 0.00020612 |   0.0 |  0.00
Modify  | 0.3724     | 0.3724     | 0.3724     |   0.0 |  1.17
Other   |            | 0.06572    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5442.00 ave        5442 max        5442 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331714.0 ave      331714 max      331714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331714
Ave neighs/atom = 165.85700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.563358926053, Press = 0.439407099291207
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -8013.6348   -8013.6348   -8095.4942   -8095.4942     316.8045     316.8045    21582.456    21582.456    1531.6631    1531.6631 
  108000   -8013.0411   -8013.0411   -8094.1422   -8094.1422    313.86944    313.86944    21635.304    21635.304   -2277.7279   -2277.7279 
Loop time of 31.8647 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.851 hours/ns, 31.383 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    | 31.308     | 31.308     | 31.308     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12465    | 0.12465    | 0.12465    |   0.0 |  0.39
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.36675    | 0.36675    | 0.36675    |   0.0 |  1.15
Other   |            | 0.06555    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331930.0 ave      331930 max      331930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331930
Ave neighs/atom = 165.96500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.567738910691, Press = -0.314250585806182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -8013.0411   -8013.0411   -8094.1422   -8094.1422    313.86944    313.86944    21635.304    21635.304   -2277.7279   -2277.7279 
  109000   -8017.6218   -8017.6218   -8099.1261   -8099.1261    315.43027    315.43027     21594.33     21594.33    344.32664    344.32664 
Loop time of 32.0972 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.692 ns/day, 8.916 hours/ns, 31.155 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    | 31.534     | 31.534     | 31.534     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12607    | 0.12607    | 0.12607    |   0.0 |  0.39
Output  | 0.00015773 | 0.00015773 | 0.00015773 |   0.0 |  0.00
Modify  | 0.37217    | 0.37217    | 0.37217    |   0.0 |  1.16
Other   |            | 0.06517    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5454.00 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331268.0 ave      331268 max      331268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331268
Ave neighs/atom = 165.63400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.561451910823, Press = -0.184452233222054
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -8017.6218   -8017.6218   -8099.1261   -8099.1261    315.43027    315.43027     21594.33     21594.33    344.32664    344.32664 
  110000   -8014.8089   -8014.8089   -8097.7607   -8097.7607    321.03215    321.03215    21608.406    21608.406   -630.59532   -630.59532 
Loop time of 32.7788 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.105 hours/ns, 30.508 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    | 32.205     | 32.205     | 32.205     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12681    | 0.12681    | 0.12681    |   0.0 |  0.39
Output  | 0.00015574 | 0.00015574 | 0.00015574 |   0.0 |  0.00
Modify  | 0.38083    | 0.38083    | 0.38083    |   0.0 |  1.16
Other   |            | 0.06603    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331990.0 ave      331990 max      331990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331990
Ave neighs/atom = 165.99500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.530079792163, Press = 0.255131581630158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -8014.8089   -8014.8089   -8097.7607   -8097.7607    321.03215    321.03215    21608.406    21608.406   -630.59532   -630.59532 
  111000   -8013.6518   -8013.6518   -8096.0405   -8096.0405    318.85266    318.85266    21690.862    21690.862   -4952.1522   -4952.1522 
Loop time of 32.8369 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.631 ns/day, 9.121 hours/ns, 30.454 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    | 32.261     | 32.261     | 32.261     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12793    | 0.12793    | 0.12793    |   0.0 |  0.39
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.3816     | 0.3816     | 0.3816     |   0.0 |  1.16
Other   |            | 0.06642    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331548.0 ave      331548 max      331548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331548
Ave neighs/atom = 165.77400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.524718984896, Press = -0.41206365632128
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -8013.6518   -8013.6518   -8096.0405   -8096.0405    318.85266    318.85266    21690.862    21690.862   -4952.1522   -4952.1522 
  112000   -8012.2183   -8012.2183   -8093.8923   -8093.8923    316.08706    316.08706    21589.931    21589.931    81.414561    81.414561 
Loop time of 32.6805 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.644 ns/day, 9.078 hours/ns, 30.599 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    | 32.106     | 32.106     | 32.106     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12774    | 0.12774    | 0.12774    |   0.0 |  0.39
Output  | 0.00015123 | 0.00015123 | 0.00015123 |   0.0 |  0.00
Modify  | 0.38032    | 0.38032    | 0.38032    |   0.0 |  1.16
Other   |            | 0.06586    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330416.0 ave      330416 max      330416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330416
Ave neighs/atom = 165.20800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.524296342525, Press = -0.390145624603181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -8012.2183   -8012.2183   -8093.8923   -8093.8923    316.08706    316.08706    21589.931    21589.931    81.414561    81.414561 
  113000   -8012.8699   -8012.8699    -8095.105    -8095.105    318.25813    318.25813    21647.702    21647.702   -1632.2429   -1632.2429 
Loop time of 32.9737 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.620 ns/day, 9.159 hours/ns, 30.327 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    | 32.401     | 32.401     | 32.401     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12752    | 0.12752    | 0.12752    |   0.0 |  0.39
Output  | 0.00019304 | 0.00019304 | 0.00019304 |   0.0 |  0.00
Modify  | 0.37951    | 0.37951    | 0.37951    |   0.0 |  1.15
Other   |            | 0.06525    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331768.0 ave      331768 max      331768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331768
Ave neighs/atom = 165.88400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.513984816692, Press = -0.177689028921413
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -8012.8699   -8012.8699    -8095.105    -8095.105    318.25813    318.25813    21647.702    21647.702   -1632.2429   -1632.2429 
  114000   -8016.9186   -8016.9186   -8095.6445   -8095.6445    304.67707    304.67707    21613.159    21613.159   -157.01633   -157.01633 
Loop time of 33.043 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.615 ns/day, 9.179 hours/ns, 30.264 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    | 32.462     | 32.462     | 32.462     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12915    | 0.12915    | 0.12915    |   0.0 |  0.39
Output  | 0.00015379 | 0.00015379 | 0.00015379 |   0.0 |  0.00
Modify  | 0.38528    | 0.38528    | 0.38528    |   0.0 |  1.17
Other   |            | 0.06616    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331050.0 ave      331050 max      331050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331050
Ave neighs/atom = 165.52500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.495897478843, Press = 0.261104743648456
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000   -8016.9186   -8016.9186   -8095.6445   -8095.6445    304.67707    304.67707    21613.159    21613.159   -157.01633   -157.01633 
  115000   -8013.3852   -8013.3852   -8093.0011   -8093.0011    308.12177    308.12177    21609.818    21609.818     731.8245     731.8245 
Loop time of 32.2592 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.678 ns/day, 8.961 hours/ns, 30.999 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    | 31.691     | 31.691     | 31.691     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12626    | 0.12626    | 0.12626    |   0.0 |  0.39
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.37528    | 0.37528    | 0.37528    |   0.0 |  1.16
Other   |            | 0.06631    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331616.0 ave      331616 max      331616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331616
Ave neighs/atom = 165.80800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.465493728135, Press = -1.43940507532671
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -8013.3852   -8013.3852   -8093.0011   -8093.0011    308.12177    308.12177    21609.818    21609.818     731.8245     731.8245 
  116000   -8017.1771   -8017.1771   -8097.5438   -8097.5438    311.02729    311.02729    21592.526    21592.526    796.60954    796.60954 
Loop time of 32.5205 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.657 ns/day, 9.033 hours/ns, 30.750 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    | 31.952     | 31.952     | 31.952     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.127      | 0.127      | 0.127      |   0.0 |  0.39
Output  | 0.00015456 | 0.00015456 | 0.00015456 |   0.0 |  0.00
Modify  | 0.37471    | 0.37471    | 0.37471    |   0.0 |  1.15
Other   |            | 0.06631    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331950.0 ave      331950 max      331950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331950
Ave neighs/atom = 165.97500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.450021698894, Press = -0.27043401143667
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -8017.1771   -8017.1771   -8097.5438   -8097.5438    311.02729    311.02729    21592.526    21592.526    796.60954    796.60954 
  117000   -8013.7094   -8013.7094    -8091.617    -8091.617    301.51069    301.51069    21615.694    21615.694    448.77383    448.77383 
Loop time of 32.2019 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.683 ns/day, 8.945 hours/ns, 31.054 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.633     | 31.633     | 31.633     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12675    | 0.12675    | 0.12675    |   0.0 |  0.39
Output  | 0.0002029  | 0.0002029  | 0.0002029  |   0.0 |  0.00
Modify  | 0.37622    | 0.37622    | 0.37622    |   0.0 |  1.17
Other   |            | 0.06581    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5445.00 ave        5445 max        5445 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332240.0 ave      332240 max      332240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332240
Ave neighs/atom = 166.12000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.453689746248, Press = 0.0670637703482529
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -8013.7094   -8013.7094    -8091.617    -8091.617    301.51069    301.51069    21615.694    21615.694    448.77383    448.77383 
  118000   -8016.0395   -8016.0395   -8096.7954   -8096.7954    312.53379    312.53379    21620.968    21620.968    401.63911    401.63911 
Loop time of 33.2163 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.601 ns/day, 9.227 hours/ns, 30.106 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    | 32.637     | 32.637     | 32.637     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12794    | 0.12794    | 0.12794    |   0.0 |  0.39
Output  | 0.00015628 | 0.00015628 | 0.00015628 |   0.0 |  0.00
Modify  | 0.38469    | 0.38469    | 0.38469    |   0.0 |  1.16
Other   |            | 0.06601    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331578.0 ave      331578 max      331578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331578
Ave neighs/atom = 165.78900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.45107841804, Press = 0.331701611891219
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -8016.0395   -8016.0395   -8096.7954   -8096.7954    312.53379    312.53379    21620.968    21620.968    401.63911    401.63911 
  119000   -8010.6661   -8010.6661   -8094.0259   -8094.0259      322.611      322.611    21589.066    21589.066     904.5533     904.5533 
Loop time of 31.8617 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.712 ns/day, 8.850 hours/ns, 31.386 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    | 31.301     | 31.301     | 31.301     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12387    | 0.12387    | 0.12387    |   0.0 |  0.39
Output  | 0.00015619 | 0.00015619 | 0.00015619 |   0.0 |  0.00
Modify  | 0.37097    | 0.37097    | 0.37097    |   0.0 |  1.16
Other   |            | 0.06547    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5428.00 ave        5428 max        5428 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331650.0 ave      331650 max      331650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331650
Ave neighs/atom = 165.82500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.46698026157, Press = -0.179520406935201
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000   -8010.6661   -8010.6661   -8094.0259   -8094.0259      322.611      322.611    21589.066    21589.066     904.5533     904.5533 
  120000   -8013.5478   -8013.5478   -8093.4562   -8093.4562    309.25376    309.25376    21623.153    21623.153   -230.70981   -230.70981 
Loop time of 32.1045 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.691 ns/day, 8.918 hours/ns, 31.148 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    | 31.537     | 31.537     | 31.537     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12598    | 0.12598    | 0.12598    |   0.0 |  0.39
Output  | 0.0001585  | 0.0001585  | 0.0001585  |   0.0 |  0.00
Modify  | 0.37482    | 0.37482    | 0.37482    |   0.0 |  1.17
Other   |            | 0.06609    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331932.0 ave      331932 max      331932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331932
Ave neighs/atom = 165.96600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.463914908674, Press = -0.49064531745733
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -8013.5478   -8013.5478   -8093.4562   -8093.4562    309.25376    309.25376    21623.153    21623.153   -230.70981   -230.70981 
  121000   -8013.4746   -8013.4746   -8095.4856   -8095.4856    317.39138    317.39138    21577.602    21577.602    1765.4038    1765.4038 
Loop time of 32.6933 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.643 ns/day, 9.081 hours/ns, 30.587 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    | 32.107     | 32.107     | 32.107     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12905    | 0.12905    | 0.12905    |   0.0 |  0.39
Output  | 0.00015142 | 0.00015142 | 0.00015142 |   0.0 |  0.00
Modify  | 0.38987    | 0.38987    | 0.38987    |   0.0 |  1.19
Other   |            | 0.06682    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331312.0 ave      331312 max      331312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331312
Ave neighs/atom = 165.65600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.460625357349, Press = -0.0727949759962726
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000   -8013.4746   -8013.4746   -8095.4856   -8095.4856    317.39138    317.39138    21577.602    21577.602    1765.4038    1765.4038 
  122000   -8015.9402   -8015.9402   -8095.9965   -8095.9965    309.82625    309.82625    21636.526    21636.526   -1822.1874   -1822.1874 
Loop time of 32.6543 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.646 ns/day, 9.071 hours/ns, 30.624 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    | 32.08      | 32.08      | 32.08      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12744    | 0.12744    | 0.12744    |   0.0 |  0.39
Output  | 0.00015746 | 0.00015746 | 0.00015746 |   0.0 |  0.00
Modify  | 0.38015    | 0.38015    | 0.38015    |   0.0 |  1.16
Other   |            | 0.0667     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332096.0 ave      332096 max      332096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332096
Ave neighs/atom = 166.04800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.462447182382, Press = 0.636375271454108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  122000   -8015.9402   -8015.9402   -8095.9965   -8095.9965    309.82625    309.82625    21636.526    21636.526   -1822.1874   -1822.1874 
  123000   -8009.5553   -8009.5553   -8092.1657   -8092.1657    319.71087    319.71087    21627.479    21627.479   -555.36844   -555.36844 
Loop time of 32.5577 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.044 hours/ns, 30.715 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    | 31.983     | 31.983     | 31.983     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.39
Output  | 0.00018662 | 0.00018662 | 0.00018662 |   0.0 |  0.00
Modify  | 0.38128    | 0.38128    | 0.38128    |   0.0 |  1.17
Other   |            | 0.06587    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331492.0 ave      331492 max      331492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331492
Ave neighs/atom = 165.74600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.480794978472, Press = -0.0460541247462962
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  123000   -8009.5553   -8009.5553   -8092.1657   -8092.1657    319.71087    319.71087    21627.479    21627.479   -555.36844   -555.36844 
  124000   -8013.9991   -8013.9991   -8096.4333   -8096.4333     319.0287     319.0287    21681.609    21681.609   -3901.1585   -3901.1585 
Loop time of 32.1911 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.684 ns/day, 8.942 hours/ns, 31.064 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    | 31.625     | 31.625     | 31.625     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12704    | 0.12704    | 0.12704    |   0.0 |  0.39
Output  | 0.0001571  | 0.0001571  | 0.0001571  |   0.0 |  0.00
Modify  | 0.37304    | 0.37304    | 0.37304    |   0.0 |  1.16
Other   |            | 0.06608    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331392.0 ave      331392 max      331392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331392
Ave neighs/atom = 165.69600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.468729721586, Press = -0.433652557795827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  124000   -8013.9991   -8013.9991   -8096.4333   -8096.4333     319.0287     319.0287    21681.609    21681.609   -3901.1585   -3901.1585 
  125000   -8018.6206   -8018.6206   -8097.2445   -8097.2445    304.28264    304.28264    21599.167    21599.167    -20.27977    -20.27977 
Loop time of 32.7185 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.641 ns/day, 9.088 hours/ns, 30.564 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    | 32.148     | 32.148     | 32.148     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1261     | 0.1261     | 0.1261     |   0.0 |  0.39
Output  | 0.00015607 | 0.00015607 | 0.00015607 |   0.0 |  0.00
Modify  | 0.3784     | 0.3784     | 0.3784     |   0.0 |  1.16
Other   |            | 0.06567    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330602.0 ave      330602 max      330602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330602
Ave neighs/atom = 165.30100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.459935005757, Press = -0.715718236126824
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  125000   -8018.6206   -8018.6206   -8097.2445   -8097.2445    304.28264    304.28264    21599.167    21599.167    -20.27977    -20.27977 
  126000   -8013.5904   -8013.5904   -8095.6566   -8095.6566    317.60484    317.60484    21567.569    21567.569     3570.157     3570.157 
Loop time of 31.9525 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.876 hours/ns, 31.296 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    | 31.388     | 31.388     | 31.388     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12647    | 0.12647    | 0.12647    |   0.0 |  0.40
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.37169    | 0.37169    | 0.37169    |   0.0 |  1.16
Other   |            | 0.06631    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5454.00 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332178.0 ave      332178 max      332178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332178
Ave neighs/atom = 166.08900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.431021708775, Press = -0.118875455605105
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  126000   -8013.5904   -8013.5904   -8095.6566   -8095.6566    317.60484    317.60484    21567.569    21567.569     3570.157     3570.157 
  127000   -8012.2866   -8012.2866   -8094.4148   -8094.4148    317.84447    317.84447    21613.966    21613.966    147.60315    147.60315 
Loop time of 32.2379 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.680 ns/day, 8.955 hours/ns, 31.019 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    | 31.67      | 31.67      | 31.67      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12601    | 0.12601    | 0.12601    |   0.0 |  0.39
Output  | 0.00020454 | 0.00020454 | 0.00020454 |   0.0 |  0.00
Modify  | 0.37645    | 0.37645    | 0.37645    |   0.0 |  1.17
Other   |            | 0.06532    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332028.0 ave      332028 max      332028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332028
Ave neighs/atom = 166.01400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.402962364828, Press = 0.23366562785288
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  127000   -8012.2866   -8012.2866   -8094.4148   -8094.4148    317.84447    317.84447    21613.966    21613.966    147.60315    147.60315 
  128000   -8013.5896   -8013.5896   -8095.9708   -8095.9708    318.82397    318.82397    21605.212    21605.212   -883.96723   -883.96723 
Loop time of 33.6586 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.567 ns/day, 9.350 hours/ns, 29.710 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    | 33.071     | 33.071     | 33.071     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13129    | 0.13129    | 0.13129    |   0.0 |  0.39
Output  | 0.00019757 | 0.00019757 | 0.00019757 |   0.0 |  0.00
Modify  | 0.38997    | 0.38997    | 0.38997    |   0.0 |  1.16
Other   |            | 0.06627    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331478.0 ave      331478 max      331478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331478
Ave neighs/atom = 165.73900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.391373066546, Press = -0.0690733516319919
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  128000   -8013.5896   -8013.5896   -8095.9708   -8095.9708    318.82397    318.82397    21605.212    21605.212   -883.96723   -883.96723 
  129000   -8009.0618   -8009.0618    -8092.758    -8092.758    323.91271    323.91271    21633.603    21633.603   -1056.4169   -1056.4169 
Loop time of 33.3134 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.594 ns/day, 9.254 hours/ns, 30.018 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    | 32.735     | 32.735     | 32.735     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12769    | 0.12769    | 0.12769    |   0.0 |  0.38
Output  | 0.00015279 | 0.00015279 | 0.00015279 |   0.0 |  0.00
Modify  | 0.38494    | 0.38494    | 0.38494    |   0.0 |  1.16
Other   |            | 0.06598    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5415.00 ave        5415 max        5415 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331752.0 ave      331752 max      331752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331752
Ave neighs/atom = 165.87600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.398215411273, Press = -0.176771611740716
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  129000   -8009.0618   -8009.0618    -8092.758    -8092.758    323.91271    323.91271    21633.603    21633.603   -1056.4169   -1056.4169 
  130000   -8017.2333   -8017.2333   -8096.2056   -8096.2056    305.63081    305.63081    21649.221    21649.221   -3359.8068   -3359.8068 
Loop time of 33.7344 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.561 ns/day, 9.371 hours/ns, 29.643 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    | 33.146     | 33.146     | 33.146     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12956    | 0.12956    | 0.12956    |   0.0 |  0.38
Output  | 0.00019179 | 0.00019179 | 0.00019179 |   0.0 |  0.00
Modify  | 0.39186    | 0.39186    | 0.39186    |   0.0 |  1.16
Other   |            | 0.06633    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331226.0 ave      331226 max      331226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331226
Ave neighs/atom = 165.61300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.415580488782, Press = 0.243859151634961
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  130000   -8017.2333   -8017.2333   -8096.2056   -8096.2056    305.63081    305.63081    21649.221    21649.221   -3359.8068   -3359.8068 
  131000   -8015.1878   -8015.1878   -8095.8251   -8095.8251    312.07467    312.07467    21611.646    21611.646   -649.67509   -649.67509 
Loop time of 32.0077 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.699 ns/day, 8.891 hours/ns, 31.243 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    | 31.445     | 31.445     | 31.445     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1258     | 0.1258     | 0.1258     |   0.0 |  0.39
Output  | 0.00020105 | 0.00020105 | 0.00020105 |   0.0 |  0.00
Modify  | 0.37132    | 0.37132    | 0.37132    |   0.0 |  1.16
Other   |            | 0.06511    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331104.0 ave      331104 max      331104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331104
Ave neighs/atom = 165.55200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.409332543614, Press = -0.516046976102901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  131000   -8015.1878   -8015.1878   -8095.8251   -8095.8251    312.07467    312.07467    21611.646    21611.646   -649.67509   -649.67509 
  132000   -8012.8806   -8012.8806   -8094.5484   -8094.5484    316.06278    316.06278    21602.875    21602.875    453.63704    453.63704 
Loop time of 33.2125 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.601 ns/day, 9.226 hours/ns, 30.109 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    | 32.628     | 32.628     | 32.628     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12891    | 0.12891    | 0.12891    |   0.0 |  0.39
Output  | 0.0002478  | 0.0002478  | 0.0002478  |   0.0 |  0.00
Modify  | 0.38936    | 0.38936    | 0.38936    |   0.0 |  1.17
Other   |            | 0.06637    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5426.00 ave        5426 max        5426 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331902.0 ave      331902 max      331902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331902
Ave neighs/atom = 165.95100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.396496318835, Press = -0.458036031734724
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  132000   -8012.8806   -8012.8806   -8094.5484   -8094.5484    316.06278    316.06278    21602.875    21602.875    453.63704    453.63704 
  133000    -8013.739    -8013.739     -8096.23     -8096.23    319.24866    319.24866    21620.279    21620.279   -846.45295   -846.45295 
Loop time of 31.4448 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.748 ns/day, 8.735 hours/ns, 31.802 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    | 30.889     | 30.889     | 30.889     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1242     | 0.1242     | 0.1242     |   0.0 |  0.39
Output  | 0.00020127 | 0.00020127 | 0.00020127 |   0.0 |  0.00
Modify  | 0.36639    | 0.36639    | 0.36639    |   0.0 |  1.17
Other   |            | 0.06528    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331638.0 ave      331638 max      331638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331638
Ave neighs/atom = 165.81900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.398808266708, Press = -0.613677713845232
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  133000    -8013.739    -8013.739     -8096.23     -8096.23    319.24866    319.24866    21620.279    21620.279   -846.45295   -846.45295 
  134000   -8016.2493   -8016.2493   -8096.7984   -8096.7984    311.73329    311.73329    21603.705    21603.705   -558.09515   -558.09515 
Loop time of 31.745 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.722 ns/day, 8.818 hours/ns, 31.501 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    | 31.183     | 31.183     | 31.183     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12451    | 0.12451    | 0.12451    |   0.0 |  0.39
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.3713     | 0.3713     | 0.3713     |   0.0 |  1.17
Other   |            | 0.06633    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5418.00 ave        5418 max        5418 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331406.0 ave      331406 max      331406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331406
Ave neighs/atom = 165.70300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.383500420123, Press = -0.388119457688477
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  134000   -8016.2493   -8016.2493   -8096.7984   -8096.7984    311.73329    311.73329    21603.705    21603.705   -558.09515   -558.09515 
  135000   -8010.5287   -8010.5287   -8091.7957   -8091.7957    314.51192    314.51192    21626.736    21626.736   -84.093635   -84.093635 
Loop time of 31.6499 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.730 ns/day, 8.792 hours/ns, 31.596 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    | 31.091     | 31.091     | 31.091     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12458    | 0.12458    | 0.12458    |   0.0 |  0.39
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.36843    | 0.36843    | 0.36843    |   0.0 |  1.16
Other   |            | 0.06584    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332174.0 ave      332174 max      332174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332174
Ave neighs/atom = 166.08700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.389421789624, Press = -0.161349297976511
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  135000   -8010.5287   -8010.5287   -8091.7957   -8091.7957    314.51192    314.51192    21626.736    21626.736   -84.093635   -84.093635 
  136000   -8012.7896   -8012.7896   -8093.5129   -8093.5129    312.40726    312.40726    21607.468    21607.468     926.6545     926.6545 
Loop time of 32.6953 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.643 ns/day, 9.082 hours/ns, 30.585 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    | 32.119     | 32.119     | 32.119     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1276     | 0.1276     | 0.1276     |   0.0 |  0.39
Output  | 0.00015306 | 0.00015306 | 0.00015306 |   0.0 |  0.00
Modify  | 0.38241    | 0.38241    | 0.38241    |   0.0 |  1.17
Other   |            | 0.06622    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331028.0 ave      331028 max      331028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331028
Ave neighs/atom = 165.51400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.381541308109, Press = -0.0624944287592938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  136000   -8012.7896   -8012.7896   -8093.5129   -8093.5129    312.40726    312.40726    21607.468    21607.468     926.6545     926.6545 
  137000   -8018.9518   -8018.9518   -8098.5693   -8098.5693    308.12772    308.12772    21602.081    21602.081   -2274.2764   -2274.2764 
Loop time of 31.784 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.829 hours/ns, 31.462 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    | 31.225     | 31.225     | 31.225     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12466    | 0.12466    | 0.12466    |   0.0 |  0.39
Output  | 0.00015728 | 0.00015728 | 0.00015728 |   0.0 |  0.00
Modify  | 0.36928    | 0.36928    | 0.36928    |   0.0 |  1.16
Other   |            | 0.06523    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331696.0 ave      331696 max      331696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331696
Ave neighs/atom = 165.84800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.37054924664, Press = 0.279077513411452
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  137000   -8018.9518   -8018.9518   -8098.5693   -8098.5693    308.12772    308.12772    21602.081    21602.081   -2274.2764   -2274.2764 
  138000   -8013.5144   -8013.5144   -8094.6449   -8094.6449    313.98355    313.98355    21620.419    21620.419    211.42014    211.42014 
Loop time of 32.8741 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.628 ns/day, 9.132 hours/ns, 30.419 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    | 32.299     | 32.299     | 32.299     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12815    | 0.12815    | 0.12815    |   0.0 |  0.39
Output  | 0.00015721 | 0.00015721 | 0.00015721 |   0.0 |  0.00
Modify  | 0.38057    | 0.38057    | 0.38057    |   0.0 |  1.16
Other   |            | 0.06588    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331638.0 ave      331638 max      331638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331638
Ave neighs/atom = 165.81900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.359900773609, Press = 0.222167573141851
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  138000   -8013.5144   -8013.5144   -8094.6449   -8094.6449    313.98355    313.98355    21620.419    21620.419    211.42014    211.42014 
  139000   -8016.1111   -8016.1111   -8094.6997   -8094.6997      304.146      304.146    21630.705    21630.705   -2271.5537   -2271.5537 
Loop time of 31.855 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.712 ns/day, 8.849 hours/ns, 31.392 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    | 31.294     | 31.294     | 31.294     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12397    | 0.12397    | 0.12397    |   0.0 |  0.39
Output  | 0.00015596 | 0.00015596 | 0.00015596 |   0.0 |  0.00
Modify  | 0.3716     | 0.3716     | 0.3716     |   0.0 |  1.17
Other   |            | 0.06555    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331456.0 ave      331456 max      331456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331456
Ave neighs/atom = 165.72800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.362116065032, Press = -0.219641483153787
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  139000   -8016.1111   -8016.1111   -8094.6997   -8094.6997      304.146      304.146    21630.705    21630.705   -2271.5537   -2271.5537 
  140000   -8010.1759   -8010.1759   -8092.9669   -8092.9669    320.40958    320.40958    21624.402    21624.402    833.90978    833.90978 
Loop time of 32.2792 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.677 ns/day, 8.966 hours/ns, 30.980 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    | 31.711     | 31.711     | 31.711     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12657    | 0.12657    | 0.12657    |   0.0 |  0.39
Output  | 0.00015498 | 0.00015498 | 0.00015498 |   0.0 |  0.00
Modify  | 0.37583    | 0.37583    | 0.37583    |   0.0 |  1.16
Other   |            | 0.06593    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331344.0 ave      331344 max      331344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331344
Ave neighs/atom = 165.67200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.378899107378, Press = -0.957359349036717
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  140000   -8010.1759   -8010.1759   -8092.9669   -8092.9669    320.40958    320.40958    21624.402    21624.402    833.90978    833.90978 
  141000   -8012.9886   -8012.9886   -8095.2707   -8095.2707    318.44022    318.44022     21613.09     21613.09   -1570.3784   -1570.3784 
Loop time of 33.6637 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.567 ns/day, 9.351 hours/ns, 29.706 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    | 33.079     | 33.079     | 33.079     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12998    | 0.12998    | 0.12998    |   0.0 |  0.39
Output  | 0.00015373 | 0.00015373 | 0.00015373 |   0.0 |  0.00
Modify  | 0.38862    | 0.38862    | 0.38862    |   0.0 |  1.15
Other   |            | 0.0659     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5442.00 ave        5442 max        5442 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331652.0 ave      331652 max      331652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331652
Ave neighs/atom = 165.82600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.378511882385, Press = -0.143126215781563
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  141000   -8012.9886   -8012.9886   -8095.2707   -8095.2707    318.44022    318.44022     21613.09     21613.09   -1570.3784   -1570.3784 
  142000    -8014.724    -8014.724   -8096.6204   -8096.6204    316.94748    316.94748    21554.594    21554.594    4050.2224    4050.2224 
Loop time of 31.8008 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.834 hours/ns, 31.446 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    | 31.243     | 31.243     | 31.243     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12571    | 0.12571    | 0.12571    |   0.0 |  0.40
Output  | 0.00014968 | 0.00014968 | 0.00014968 |   0.0 |  0.00
Modify  | 0.36654    | 0.36654    | 0.36654    |   0.0 |  1.15
Other   |            | 0.06546    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331876.0 ave      331876 max      331876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331876
Ave neighs/atom = 165.93800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.377569367747, Press = -0.788955992596931
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  142000    -8014.724    -8014.724   -8096.6204   -8096.6204    316.94748    316.94748    21554.594    21554.594    4050.2224    4050.2224 
  143000   -8016.0517   -8016.0517   -8095.3071   -8095.3071    306.72679    306.72679    21591.785    21591.785    564.84845    564.84845 
Loop time of 31.9567 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.877 hours/ns, 31.292 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    | 31.389     | 31.389     | 31.389     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12771    | 0.12771    | 0.12771    |   0.0 |  0.40
Output  | 0.00015424 | 0.00015424 | 0.00015424 |   0.0 |  0.00
Modify  | 0.374      | 0.374      | 0.374      |   0.0 |  1.17
Other   |            | 0.06542    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332708.0 ave      332708 max      332708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332708
Ave neighs/atom = 166.35400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.376783602098, Press = 0.422851421014469
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  143000   -8016.0517   -8016.0517   -8095.3071   -8095.3071    306.72679    306.72679    21591.785    21591.785    564.84845    564.84845 
  144000   -8014.2207   -8014.2207   -8095.9404   -8095.9404    316.26357    316.26357     21592.64     21592.64    1214.3962    1214.3962 
Loop time of 31.8761 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.710 ns/day, 8.854 hours/ns, 31.371 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    | 31.315     | 31.315     | 31.315     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12677    | 0.12677    | 0.12677    |   0.0 |  0.40
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.36826    | 0.36826    | 0.36826    |   0.0 |  1.16
Other   |            | 0.06576    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332062.0 ave      332062 max      332062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332062
Ave neighs/atom = 166.03100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.38403764192, Press = 0.256186468937195
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  144000   -8014.2207   -8014.2207   -8095.9404   -8095.9404    316.26357    316.26357     21592.64     21592.64    1214.3962    1214.3962 
  145000   -8013.8482   -8013.8482   -8091.8367   -8091.8367    301.82358    301.82358    21619.432    21619.432   -131.15097   -131.15097 
Loop time of 31.8317 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.714 ns/day, 8.842 hours/ns, 31.415 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    | 31.271     | 31.271     | 31.271     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12635    | 0.12635    | 0.12635    |   0.0 |  0.40
Output  | 0.00019448 | 0.00019448 | 0.00019448 |   0.0 |  0.00
Modify  | 0.36817    | 0.36817    | 0.36817    |   0.0 |  1.16
Other   |            | 0.0659     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331958.0 ave      331958 max      331958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331958
Ave neighs/atom = 165.97900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.375760398959, Press = -0.257946223566293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  145000   -8013.8482   -8013.8482   -8091.8367   -8091.8367    301.82358    301.82358    21619.432    21619.432   -131.15097   -131.15097 
  146000   -8013.0118   -8013.0118    -8094.136    -8094.136    313.95878    313.95878    21611.473    21611.473    383.62188    383.62188 
Loop time of 31.9522 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.876 hours/ns, 31.297 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    | 31.392     | 31.392     | 31.392     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12469    | 0.12469    | 0.12469    |   0.0 |  0.39
Output  | 0.00015458 | 0.00015458 | 0.00015458 |   0.0 |  0.00
Modify  | 0.37003    | 0.37003    | 0.37003    |   0.0 |  1.16
Other   |            | 0.06548    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331716.0 ave      331716 max      331716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331716
Ave neighs/atom = 165.85800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.397368450414, Press = 0.526532294196722
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  146000   -8013.0118   -8013.0118    -8094.136    -8094.136    313.95878    313.95878    21611.473    21611.473    383.62188    383.62188 
  147000   -8013.5016   -8013.5016   -8094.7697   -8094.7697    314.51618    314.51618    21616.178    21616.178   -938.01964   -938.01964 
Loop time of 32.1635 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.686 ns/day, 8.934 hours/ns, 31.091 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    | 31.598     | 31.598     | 31.598     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12588    | 0.12588    | 0.12588    |   0.0 |  0.39
Output  | 0.00019212 | 0.00019212 | 0.00019212 |   0.0 |  0.00
Modify  | 0.37371    | 0.37371    | 0.37371    |   0.0 |  1.16
Other   |            | 0.06545    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331614.0 ave      331614 max      331614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331614
Ave neighs/atom = 165.80700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.403650621478, Press = 0.0363998575364899
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  147000   -8013.5016   -8013.5016   -8094.7697   -8094.7697    314.51618    314.51618    21616.178    21616.178   -938.01964   -938.01964 
  148000   -8014.1703   -8014.1703   -8095.0164   -8095.0164    312.88279    312.88279    21592.323    21592.323    113.53547    113.53547 
Loop time of 32.9351 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.623 ns/day, 9.149 hours/ns, 30.363 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    | 32.363     | 32.363     | 32.363     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12798    | 0.12798    | 0.12798    |   0.0 |  0.39
Output  | 0.00015549 | 0.00015549 | 0.00015549 |   0.0 |  0.00
Modify  | 0.37873    | 0.37873    | 0.37873    |   0.0 |  1.15
Other   |            | 0.06557    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331678.0 ave      331678 max      331678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331678
Ave neighs/atom = 165.83900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.408871853492, Press = -0.192264830905719
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  148000   -8014.1703   -8014.1703   -8095.0164   -8095.0164    312.88279    312.88279    21592.323    21592.323    113.53547    113.53547 
  149000   -8011.8725   -8011.8725   -8094.7613   -8094.7613    320.78823    320.78823    21575.624    21575.624    2238.4098    2238.4098 
Loop time of 32.0731 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.694 ns/day, 8.909 hours/ns, 31.179 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    | 31.511     | 31.511     | 31.511     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12469    | 0.12469    | 0.12469    |   0.0 |  0.39
Output  | 0.00015092 | 0.00015092 | 0.00015092 |   0.0 |  0.00
Modify  | 0.37185    | 0.37185    | 0.37185    |   0.0 |  1.16
Other   |            | 0.06558    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331806.0 ave      331806 max      331806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331806
Ave neighs/atom = 165.90300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.417425639139, Press = -0.857087728003628
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  149000   -8011.8725   -8011.8725   -8094.7613   -8094.7613    320.78823    320.78823    21575.624    21575.624    2238.4098    2238.4098 
  150000   -8017.6578   -8017.6578    -8096.244    -8096.244    304.13639    304.13639    21584.499    21584.499    705.18798    705.18798 
Loop time of 31.5373 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.760 hours/ns, 31.708 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    | 30.983     | 30.983     | 30.983     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12357    | 0.12357    | 0.12357    |   0.0 |  0.39
Output  | 0.00019554 | 0.00019554 | 0.00019554 |   0.0 |  0.00
Modify  | 0.36512    | 0.36512    | 0.36512    |   0.0 |  1.16
Other   |            | 0.06564    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332228.0 ave      332228 max      332228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332228
Ave neighs/atom = 166.11400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.41561180125, Press = 0.0554911334452986
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  150000   -8017.6578   -8017.6578    -8096.244    -8096.244    304.13639    304.13639    21584.499    21584.499    705.18798    705.18798 
  151000   -8016.2277   -8016.2277   -8095.5845   -8095.5845    307.11912    307.11912    21623.433    21623.433   -828.85169   -828.85169 
Loop time of 32.1636 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.686 ns/day, 8.934 hours/ns, 31.091 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    | 31.595     | 31.595     | 31.595     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12631    | 0.12631    | 0.12631    |   0.0 |  0.39
Output  | 0.00015426 | 0.00015426 | 0.00015426 |   0.0 |  0.00
Modify  | 0.3765     | 0.3765     | 0.3765     |   0.0 |  1.17
Other   |            | 0.06598    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332334.0 ave      332334 max      332334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332334
Ave neighs/atom = 166.16700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.414850508814, Press = 0.554397658567896
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  151000   -8016.2277   -8016.2277   -8095.5845   -8095.5845    307.11912    307.11912    21623.433    21623.433   -828.85169   -828.85169 
  152000   -8011.2199   -8011.2199   -8094.6437   -8094.6437    322.85856    322.85856    21628.022    21628.022   -1235.0068   -1235.0068 
Loop time of 31.7909 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.831 hours/ns, 31.456 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    | 31.231     | 31.231     | 31.231     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1245     | 0.1245     | 0.1245     |   0.0 |  0.39
Output  | 0.0001531  | 0.0001531  | 0.0001531  |   0.0 |  0.00
Modify  | 0.36961    | 0.36961    | 0.36961    |   0.0 |  1.16
Other   |            | 0.06584    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5428.00 ave        5428 max        5428 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331328.0 ave      331328 max      331328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331328
Ave neighs/atom = 165.66400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.431116764618, Press = -0.592940392567245
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  152000   -8011.2199   -8011.2199   -8094.6437   -8094.6437    322.85856    322.85856    21628.022    21628.022   -1235.0068   -1235.0068 
  153000   -8017.3937   -8017.3937   -8097.3935   -8097.3935    309.60778    309.60778    21582.403    21582.403    397.74017    397.74017 
Loop time of 31.9217 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.707 ns/day, 8.867 hours/ns, 31.327 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    | 31.358     | 31.358     | 31.358     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12591    | 0.12591    | 0.12591    |   0.0 |  0.39
Output  | 0.00015785 | 0.00015785 | 0.00015785 |   0.0 |  0.00
Modify  | 0.37195    | 0.37195    | 0.37195    |   0.0 |  1.17
Other   |            | 0.06529    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331244.0 ave      331244 max      331244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331244
Ave neighs/atom = 165.62200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.41747873586, Press = -0.294733889359674
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  153000   -8017.3937   -8017.3937   -8097.3935   -8097.3935    309.60778    309.60778    21582.403    21582.403    397.74017    397.74017 
  154000   -8013.2642   -8013.2642   -8093.6061   -8093.6061     310.9317     310.9317    21592.532    21592.532    1430.8549    1430.8549 
Loop time of 32.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.660 ns/day, 9.023 hours/ns, 30.784 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    | 31.915     | 31.915     | 31.915     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12611    | 0.12611    | 0.12611    |   0.0 |  0.39
Output  | 0.00020401 | 0.00020401 | 0.00020401 |   0.0 |  0.00
Modify  | 0.37688    | 0.37688    | 0.37688    |   0.0 |  1.16
Other   |            | 0.06584    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332302.0 ave      332302 max      332302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332302
Ave neighs/atom = 166.15100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.417858710515, Press = 0.0804595839594903
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  154000   -8013.2642   -8013.2642   -8093.6061   -8093.6061     310.9317     310.9317    21592.532    21592.532    1430.8549    1430.8549 
  155000   -8012.7269   -8012.7269   -8094.9636   -8094.9636    318.26482    318.26482    21604.948    21604.948     779.1911     779.1911 
Loop time of 32.9657 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.621 ns/day, 9.157 hours/ns, 30.335 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    | 32.389     | 32.389     | 32.389     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12932    | 0.12932    | 0.12932    |   0.0 |  0.39
Output  | 0.00015609 | 0.00015609 | 0.00015609 |   0.0 |  0.00
Modify  | 0.38116    | 0.38116    | 0.38116    |   0.0 |  1.16
Other   |            | 0.06559    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5458.00 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332118.0 ave      332118 max      332118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332118
Ave neighs/atom = 166.05900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.406855122068, Press = 0.356107796788032
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  155000   -8012.7269   -8012.7269   -8094.9636   -8094.9636    318.26482    318.26482    21604.948    21604.948     779.1911     779.1911 
  156000   -8013.5838   -8013.5838   -8096.3487   -8096.3487    320.30897    320.30897    21639.642    21639.642   -1596.5819   -1596.5819 
Loop time of 31.3912 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.752 ns/day, 8.720 hours/ns, 31.856 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    | 30.836     | 30.836     | 30.836     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12459    | 0.12459    | 0.12459    |   0.0 |  0.40
Output  | 0.00015503 | 0.00015503 | 0.00015503 |   0.0 |  0.00
Modify  | 0.36457    | 0.36457    | 0.36457    |   0.0 |  1.16
Other   |            | 0.06581    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5415.00 ave        5415 max        5415 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331972.0 ave      331972 max      331972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331972
Ave neighs/atom = 165.98600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.397257172319, Press = 0.471407779970915
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  156000   -8013.5838   -8013.5838   -8096.3487   -8096.3487    320.30897    320.30897    21639.642    21639.642   -1596.5819   -1596.5819 
  157000   -8012.4959   -8012.4959   -8094.2358   -8094.2358    316.34192    316.34192    21613.585    21613.585    493.78632    493.78632 
Loop time of 32.2141 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.682 ns/day, 8.948 hours/ns, 31.042 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    | 31.645     | 31.645     | 31.645     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1274     | 0.1274     | 0.1274     |   0.0 |  0.40
Output  | 0.00015563 | 0.00015563 | 0.00015563 |   0.0 |  0.00
Modify  | 0.37591    | 0.37591    | 0.37591    |   0.0 |  1.17
Other   |            | 0.06583    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331144.0 ave      331144 max      331144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331144
Ave neighs/atom = 165.57200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.386818561991, Press = -0.106843125554128
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  157000   -8012.4959   -8012.4959   -8094.2358   -8094.2358    316.34192    316.34192    21613.585    21613.585    493.78632    493.78632 
  158000   -8019.9715   -8019.9715    -8097.896    -8097.896    301.57609    301.57609    21592.141    21592.141    711.85065    711.85065 
Loop time of 33.0223 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.616 ns/day, 9.173 hours/ns, 30.283 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    | 32.442     | 32.442     | 32.442     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12923    | 0.12923    | 0.12923    |   0.0 |  0.39
Output  | 0.00015367 | 0.00015367 | 0.00015367 |   0.0 |  0.00
Modify  | 0.385      | 0.385      | 0.385      |   0.0 |  1.17
Other   |            | 0.06635    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331646.0 ave      331646 max      331646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331646
Ave neighs/atom = 165.82300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.372236744368, Press = 0.137091399404748
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  158000   -8019.9715   -8019.9715    -8097.896    -8097.896    301.57609    301.57609    21592.141    21592.141    711.85065    711.85065 
  159000   -8011.9517   -8011.9517   -8095.4376   -8095.4376    323.09925    323.09925    21635.006    21635.006   -1139.0139   -1139.0139 
Loop time of 32.1127 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.691 ns/day, 8.920 hours/ns, 31.140 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    | 31.547     | 31.547     | 31.547     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1268     | 0.1268     | 0.1268     |   0.0 |  0.39
Output  | 0.00024306 | 0.00024306 | 0.00024306 |   0.0 |  0.00
Modify  | 0.37307    | 0.37307    | 0.37307    |   0.0 |  1.16
Other   |            | 0.06529    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332142.0 ave      332142 max      332142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332142
Ave neighs/atom = 166.07100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363439367622, Press = -0.611226174532897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  159000   -8011.9517   -8011.9517   -8095.4376   -8095.4376    323.09925    323.09925    21635.006    21635.006   -1139.0139   -1139.0139 
  160000   -8011.9444   -8011.9444   -8096.3313   -8096.3313    326.58574    326.58574    21571.338    21571.338    2345.9894    2345.9894 
Loop time of 31.6749 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.728 ns/day, 8.799 hours/ns, 31.571 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    | 31.117     | 31.117     | 31.117     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12516    | 0.12516    | 0.12516    |   0.0 |  0.40
Output  | 0.00019646 | 0.00019646 | 0.00019646 |   0.0 |  0.00
Modify  | 0.36724    | 0.36724    | 0.36724    |   0.0 |  1.16
Other   |            | 0.06569    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331460.0 ave      331460 max      331460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331460
Ave neighs/atom = 165.73000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.345280627465, Press = -0.215158633443403
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  160000   -8011.9444   -8011.9444   -8096.3313   -8096.3313    326.58574    326.58574    21571.338    21571.338    2345.9894    2345.9894 
  161000   -8011.7349   -8011.7349   -8094.2796   -8094.2796    319.45653    319.45653    21612.363    21612.363    475.38531    475.38531 
Loop time of 32.7379 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.639 ns/day, 9.094 hours/ns, 30.546 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    | 32.165     | 32.165     | 32.165     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12815    | 0.12815    | 0.12815    |   0.0 |  0.39
Output  | 0.00015612 | 0.00015612 | 0.00015612 |   0.0 |  0.00
Modify  | 0.37869    | 0.37869    | 0.37869    |   0.0 |  1.16
Other   |            | 0.06587    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332442.0 ave      332442 max      332442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332442
Ave neighs/atom = 166.22100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.345438818878, Press = -0.22053079140235
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  161000   -8011.7349   -8011.7349   -8094.2796   -8094.2796    319.45653    319.45653    21612.363    21612.363    475.38531    475.38531 
  162000   -8016.8877   -8016.8877    -8095.134    -8095.134    302.82151    302.82151     21617.45     21617.45   -852.83198   -852.83198 
Loop time of 31.5085 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.742 ns/day, 8.752 hours/ns, 31.737 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    | 30.95      | 30.95      | 30.95      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12527    | 0.12527    | 0.12527    |   0.0 |  0.40
Output  | 0.00019151 | 0.00019151 | 0.00019151 |   0.0 |  0.00
Modify  | 0.36725    | 0.36725    | 0.36725    |   0.0 |  1.17
Other   |            | 0.0657     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331624.0 ave      331624 max      331624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331624
Ave neighs/atom = 165.81200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.360541500415, Press = 0.441076089649399
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  162000   -8016.8877   -8016.8877    -8095.134    -8095.134    302.82151    302.82151     21617.45     21617.45   -852.83198   -852.83198 
  163000   -8013.2552   -8013.2552   -8094.6987   -8094.6987    315.19461    315.19461    21597.404    21597.404    1110.6842    1110.6842 
Loop time of 32.3508 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.986 hours/ns, 30.911 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    | 31.784     | 31.784     | 31.784     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12567    | 0.12567    | 0.12567    |   0.0 |  0.39
Output  | 0.00015738 | 0.00015738 | 0.00015738 |   0.0 |  0.00
Modify  | 0.37569    | 0.37569    | 0.37569    |   0.0 |  1.16
Other   |            | 0.06575    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331774.0 ave      331774 max      331774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331774
Ave neighs/atom = 165.88700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.360862222367, Press = 0.12845557876325
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  163000   -8013.2552   -8013.2552   -8094.6987   -8094.6987    315.19461    315.19461    21597.404    21597.404    1110.6842    1110.6842 
  164000   -8010.4926   -8010.4926   -8092.0059   -8092.0059    315.46495    315.46495    21618.239    21618.239    1098.1399    1098.1399 
Loop time of 32.0542 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.695 ns/day, 8.904 hours/ns, 31.197 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    | 31.489     | 31.489     | 31.489     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12567    | 0.12567    | 0.12567    |   0.0 |  0.39
Output  | 0.00015029 | 0.00015029 | 0.00015029 |   0.0 |  0.00
Modify  | 0.37299    | 0.37299    | 0.37299    |   0.0 |  1.16
Other   |            | 0.06593    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331684.0 ave      331684 max      331684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331684
Ave neighs/atom = 165.84200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.357620184617, Press = 0.0416024398773218
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  164000   -8010.4926   -8010.4926   -8092.0059   -8092.0059    315.46495    315.46495    21618.239    21618.239    1098.1399    1098.1399 
  165000   -8015.3024   -8015.3024    -8095.399    -8095.399    309.98221    309.98221    21593.691    21593.691    527.65496    527.65496 
Loop time of 31.6602 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.729 ns/day, 8.795 hours/ns, 31.585 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    | 31.099     | 31.099     | 31.099     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12397    | 0.12397    | 0.12397    |   0.0 |  0.39
Output  | 0.00015337 | 0.00015337 | 0.00015337 |   0.0 |  0.00
Modify  | 0.37072    | 0.37072    | 0.37072    |   0.0 |  1.17
Other   |            | 0.06608    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5428.00 ave        5428 max        5428 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331748.0 ave      331748 max      331748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331748
Ave neighs/atom = 165.87400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.370022890198, Press = 0.451423346078616
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  165000   -8015.3024   -8015.3024    -8095.399    -8095.399    309.98221    309.98221    21593.691    21593.691    527.65496    527.65496 
  166000   -8012.6284   -8012.6284   -8094.0775   -8094.0775    315.21674    315.21674    21627.058    21627.058   -177.07108   -177.07108 
Loop time of 31.6259 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.732 ns/day, 8.785 hours/ns, 31.620 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    | 31.069     | 31.069     | 31.069     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12418    | 0.12418    | 0.12418    |   0.0 |  0.39
Output  | 0.00019233 | 0.00019233 | 0.00019233 |   0.0 |  0.00
Modify  | 0.36715    | 0.36715    | 0.36715    |   0.0 |  1.16
Other   |            | 0.06495    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332146.0 ave      332146 max      332146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332146
Ave neighs/atom = 166.07300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.377548692768, Press = -0.371460634854338
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  166000   -8012.6284   -8012.6284   -8094.0775   -8094.0775    315.21674    315.21674    21627.058    21627.058   -177.07108   -177.07108 
  167000   -8011.8301   -8011.8301   -8094.1145   -8094.1145    318.44916    318.44916    21661.695    21661.695   -2960.4729   -2960.4729 
Loop time of 32.5684 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.653 ns/day, 9.047 hours/ns, 30.705 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    | 31.996     | 31.996     | 31.996     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12636    | 0.12636    | 0.12636    |   0.0 |  0.39
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.38004    | 0.38004    | 0.38004    |   0.0 |  1.17
Other   |            | 0.06558    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331382.0 ave      331382 max      331382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331382
Ave neighs/atom = 165.69100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.372514979303, Press = 0.226803711703148
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  167000   -8011.8301   -8011.8301   -8094.1145   -8094.1145    318.44916    318.44916    21661.695    21661.695   -2960.4729   -2960.4729 
  168000    -8013.332    -8013.332   -8093.5733   -8093.5733    310.54244    310.54244    21644.666    21644.666   -2660.5637   -2660.5637 
Loop time of 32 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.700 ns/day, 8.889 hours/ns, 31.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    | 31.429     | 31.429     | 31.429     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12711    | 0.12711    | 0.12711    |   0.0 |  0.40
Output  | 0.00015592 | 0.00015592 | 0.00015592 |   0.0 |  0.00
Modify  | 0.37739    | 0.37739    | 0.37739    |   0.0 |  1.18
Other   |            | 0.06637    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331096.0 ave      331096 max      331096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331096
Ave neighs/atom = 165.54800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.366574500712, Press = 0.00684046613998398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  168000    -8013.332    -8013.332   -8093.5733   -8093.5733    310.54244    310.54244    21644.666    21644.666   -2660.5637   -2660.5637 
  169000    -8012.975    -8012.975   -8094.0356   -8094.0356    313.71267    313.71267    21633.358    21633.358   -951.86394   -951.86394 
Loop time of 31.9861 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.701 ns/day, 8.885 hours/ns, 31.264 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    | 31.424     | 31.424     | 31.424     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12457    | 0.12457    | 0.12457    |   0.0 |  0.39
Output  | 0.00015293 | 0.00015293 | 0.00015293 |   0.0 |  0.00
Modify  | 0.37167    | 0.37167    | 0.37167    |   0.0 |  1.16
Other   |            | 0.06557    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5423.00 ave        5423 max        5423 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331258.0 ave      331258 max      331258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331258
Ave neighs/atom = 165.62900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.35923046627, Press = -0.0641114316731183
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  169000    -8012.975    -8012.975   -8094.0356   -8094.0356    313.71267    313.71267    21633.358    21633.358   -951.86394   -951.86394 
  170000   -8016.3322   -8016.3322   -8096.3945   -8096.3945     309.8494     309.8494    21617.855    21617.855   -1297.7087   -1297.7087 
Loop time of 31.4296 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.749 ns/day, 8.730 hours/ns, 31.817 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    | 30.871     | 30.871     | 30.871     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12499    | 0.12499    | 0.12499    |   0.0 |  0.40
Output  | 0.00015031 | 0.00015031 | 0.00015031 |   0.0 |  0.00
Modify  | 0.36706    | 0.36706    | 0.36706    |   0.0 |  1.17
Other   |            | 0.06605    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5443.00 ave        5443 max        5443 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331144.0 ave      331144 max      331144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0