# 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.860342010855675*${_u_distance}
variable latticeconst_converted equal 2.860342010855675*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86034201085568
Lattice spacing in x,y,z = 2.8603420 2.8603420 2.8603420
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.603420 28.603420 28.603420)
  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.603420 28.603420 28.603420)
  create_atoms CPU = 0.003 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_FarkasCaro_2018_FeNiCrCoCu__MO_803527979660_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 23402.0495396402    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23402.0495396402/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23402.0495396402/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23402.0495396402/(1*1*${_u_distance})
variable      V0_metal equal 23402.0495396402/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23402.0495396402*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23402.0495396402 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_803527979660_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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8520.9682   -8520.9682   -8601.8833   -8601.8833       313.15       313.15     23402.05     23402.05     3693.103     3693.103 
    1000    -8533.911    -8533.911   -8611.0562   -8611.0562    298.55996    298.55996    23811.461    23811.461    2748.5138    2748.5138 
Loop time of 31.3794 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.753 ns/day, 8.716 hours/ns, 31.868 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.624     | 30.624     | 30.624     |   0.0 | 97.59
Neigh   | 0.19061    | 0.19061    | 0.19061    |   0.0 |  0.61
Comm    | 0.13238    | 0.13238    | 0.13238    |   0.0 |  0.42
Output  | 0.00024037 | 0.00024037 | 0.00024037 |   0.0 |  0.00
Modify  | 0.3661     | 0.3661     | 0.3661     |   0.0 |  1.17
Other   |            | 0.0663     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5391.00 ave        5391 max        5391 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326052.0 ave      326052 max      326052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326052
Ave neighs/atom = 163.02600
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8533.911    -8533.911   -8611.0562   -8611.0562    298.55996    298.55996    23811.461    23811.461    2748.5138    2748.5138 
    2000   -8574.8725   -8574.8725   -8655.5513   -8655.5513    312.23529    312.23529    23683.766    23683.766   -2233.4057   -2233.4057 
Loop time of 31.4317 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.749 ns/day, 8.731 hours/ns, 31.815 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.699     | 30.699     | 30.699     |   0.0 | 97.67
Neigh   | 0.1892     | 0.1892     | 0.1892     |   0.0 |  0.60
Comm    | 0.1272     | 0.1272     | 0.1272     |   0.0 |  0.40
Output  | 0.00023329 | 0.00023329 | 0.00023329 |   0.0 |  0.00
Modify  | 0.35176    | 0.35176    | 0.35176    |   0.0 |  1.12
Other   |            | 0.06464    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5381.00 ave        5381 max        5381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327342.0 ave      327342 max      327342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327342
Ave neighs/atom = 163.67100
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8574.8725   -8574.8725   -8655.5513   -8655.5513    312.23529    312.23529    23683.766    23683.766   -2233.4057   -2233.4057 
    3000   -8579.2597   -8579.2597   -8662.6967   -8662.6967    322.90998    322.90998    23645.307    23645.307    1154.8778    1154.8778 
Loop time of 30.6137 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.822 ns/day, 8.504 hours/ns, 32.665 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.079     | 30.079     | 30.079     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12395    | 0.12395    | 0.12395    |   0.0 |  0.40
Output  | 0.00019806 | 0.00019806 | 0.00019806 |   0.0 |  0.00
Modify  | 0.34575    | 0.34575    | 0.34575    |   0.0 |  1.13
Other   |            | 0.06497    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327354.0 ave      327354 max      327354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327354
Ave neighs/atom = 163.67700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.2597   -8579.2597   -8662.6967   -8662.6967    322.90998    322.90998    23645.307    23645.307    1154.8778    1154.8778 
    4000   -8575.1378   -8575.1378   -8657.2852   -8657.2852    317.91889    317.91889    23666.383    23666.383   -90.678807   -90.678807 
Loop time of 31.1041 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.778 ns/day, 8.640 hours/ns, 32.150 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.558     | 30.558     | 30.558     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12581    | 0.12581    | 0.12581    |   0.0 |  0.40
Output  | 0.00018743 | 0.00018743 | 0.00018743 |   0.0 |  0.00
Modify  | 0.35441    | 0.35441    | 0.35441    |   0.0 |  1.14
Other   |            | 0.06522    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5386.00 ave        5386 max        5386 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327222.0 ave      327222 max      327222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327222
Ave neighs/atom = 163.61100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8575.1378   -8575.1378   -8657.2852   -8657.2852    317.91889    317.91889    23666.383    23666.383   -90.678807   -90.678807 
    5000   -8576.8786   -8576.8786    -8658.574    -8658.574    316.16978    316.16978    23664.526    23664.526    850.06248    850.06248 
Loop time of 31.5365 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.760 hours/ns, 31.709 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.979     | 30.979     | 30.979     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1269     | 0.1269     | 0.1269     |   0.0 |  0.40
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.36388    | 0.36388    | 0.36388    |   0.0 |  1.15
Other   |            | 0.06615    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327380.0 ave      327380 max      327380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327380
Ave neighs/atom = 163.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 = 312.218960092372, Press = -1003.85176416949
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.8786   -8576.8786    -8658.574    -8658.574    316.16978    316.16978    23664.526    23664.526    850.06248    850.06248 
    6000   -8578.6655   -8578.6655   -8659.0359   -8659.0359      311.042      311.042     23669.42     23669.42   -1372.5089   -1372.5089 
Loop time of 31.4792 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.744 hours/ns, 31.767 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.912     | 30.912     | 30.912     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12651    | 0.12651    | 0.12651    |   0.0 |  0.40
Output  | 0.00019404 | 0.00019404 | 0.00019404 |   0.0 |  0.00
Modify  | 0.37575    | 0.37575    | 0.37575    |   0.0 |  1.19
Other   |            | 0.0648     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5389.00 ave        5389 max        5389 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327206.0 ave      327206 max      327206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327206
Ave neighs/atom = 163.60300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.842007450525, Press = -4.22235615216756
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.6655   -8578.6655   -8659.0359   -8659.0359      311.042      311.042     23669.42     23669.42   -1372.5089   -1372.5089 
    7000   -8577.9225   -8577.9225   -8661.4108   -8661.4108    323.10826    323.10826    23682.931    23682.931   -3833.1441   -3833.1441 
Loop time of 32.1196 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.922 hours/ns, 31.134 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.532     | 31.532     | 31.532     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12938    | 0.12938    | 0.12938    |   0.0 |  0.40
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.39159    | 0.39159    | 0.39159    |   0.0 |  1.22
Other   |            | 0.06656    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5369.00 ave        5369 max        5369 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327288.0 ave      327288 max      327288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327288
Ave neighs/atom = 163.64400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.489282220189, Press = -60.0889766995563
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.9225   -8577.9225   -8661.4108   -8661.4108    323.10826    323.10826    23682.931    23682.931   -3833.1441   -3833.1441 
    8000   -8575.0301   -8575.0301   -8657.8379   -8657.8379    320.47486    320.47486    23636.921    23636.921    1357.1269    1357.1269 
Loop time of 30.8553 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.800 ns/day, 8.571 hours/ns, 32.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    | 30.3       | 30.3       | 30.3       |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12255    | 0.12255    | 0.12255    |   0.0 |  0.40
Output  | 0.00014651 | 0.00014651 | 0.00014651 |   0.0 |  0.00
Modify  | 0.36707    | 0.36707    | 0.36707    |   0.0 |  1.19
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:        5370.00 ave        5370 max        5370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326392.0 ave      326392 max      326392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326392
Ave neighs/atom = 163.19600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.263970625495, Press = -27.7967816755487
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8575.0301   -8575.0301   -8657.8379   -8657.8379    320.47486    320.47486    23636.921    23636.921    1357.1269    1357.1269 
    9000   -8583.8672   -8583.8672   -8660.9846   -8660.9846    298.45227    298.45227    23657.733    23657.733   -1302.4362   -1302.4362 
Loop time of 31.553 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.738 ns/day, 8.765 hours/ns, 31.693 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.986     | 30.986     | 30.986     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1258     | 0.1258     | 0.1258     |   0.0 |  0.40
Output  | 0.00015281 | 0.00015281 | 0.00015281 |   0.0 |  0.00
Modify  | 0.37623    | 0.37623    | 0.37623    |   0.0 |  1.19
Other   |            | 0.065      |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5378.00 ave        5378 max        5378 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327396.0 ave      327396 max      327396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327396
Ave neighs/atom = 163.69800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.707464461688, Press = 5.22121668081572
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8583.8672   -8583.8672   -8660.9846   -8660.9846    298.45227    298.45227    23657.733    23657.733   -1302.4362   -1302.4362 
   10000   -8576.5191   -8576.5191   -8658.9134   -8658.9134    318.87456    318.87456    23665.536    23665.536   -1198.8233   -1198.8233 
Loop time of 31.6747 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.095     | 31.095     | 31.095     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12699    | 0.12699    | 0.12699    |   0.0 |  0.40
Output  | 0.00015125 | 0.00015125 | 0.00015125 |   0.0 |  0.00
Modify  | 0.38639    | 0.38639    | 0.38639    |   0.0 |  1.22
Other   |            | 0.06653    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5383.00 ave        5383 max        5383 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326872.0 ave      326872 max      326872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326872
Ave neighs/atom = 163.43600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.440449299374, Press = -10.1607894220456
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.5191   -8576.5191   -8658.9134   -8658.9134    318.87456    318.87456    23665.536    23665.536   -1198.8233   -1198.8233 
   11000   -8578.4969   -8578.4969   -8659.2128   -8659.2128     312.3788     312.3788    23626.037    23626.037    2751.5486    2751.5486 
Loop time of 31.9264 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.706 ns/day, 8.868 hours/ns, 31.322 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.338     | 31.338     | 31.338     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12964    | 0.12964    | 0.12964    |   0.0 |  0.41
Output  | 0.00024244 | 0.00024244 | 0.00024244 |   0.0 |  0.00
Modify  | 0.39202    | 0.39202    | 0.39202    |   0.0 |  1.23
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:        5359.00 ave        5359 max        5359 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326896.0 ave      326896 max      326896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326896
Ave neighs/atom = 163.44800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.237230651299, Press = -15.8420502024477
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.4969   -8578.4969   -8659.2128   -8659.2128     312.3788     312.3788    23626.037    23626.037    2751.5486    2751.5486 
   12000   -8577.2018   -8577.2018   -8658.1194   -8658.1194    313.15953    313.15953    23636.574    23636.574    3336.1707    3336.1707 
Loop time of 31.7396 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.722 ns/day, 8.817 hours/ns, 31.506 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.162     | 31.162     | 31.162     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12786    | 0.12786    | 0.12786    |   0.0 |  0.40
Output  | 0.00019241 | 0.00019241 | 0.00019241 |   0.0 |  0.00
Modify  | 0.38311    | 0.38311    | 0.38311    |   0.0 |  1.21
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:        5391.00 ave        5391 max        5391 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327300.0 ave      327300 max      327300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327300
Ave neighs/atom = 163.65000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.964068145588, Press = 3.53774075371429
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.2018   -8577.2018   -8658.1194   -8658.1194    313.15953    313.15953    23636.574    23636.574    3336.1707    3336.1707 
   13000    -8579.353    -8579.353   -8660.5535   -8660.5535    314.25429    314.25429    23682.831    23682.831   -3307.6429   -3307.6429 
Loop time of 31.3959 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.752 ns/day, 8.721 hours/ns, 31.851 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.833     | 30.833     | 30.833     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12558    | 0.12558    | 0.12558    |   0.0 |  0.40
Output  | 0.00024481 | 0.00024481 | 0.00024481 |   0.0 |  0.00
Modify  | 0.37254    | 0.37254    | 0.37254    |   0.0 |  1.19
Other   |            | 0.06444    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5370.00 ave        5370 max        5370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327356.0 ave      327356 max      327356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327356
Ave neighs/atom = 163.67800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.937696668371, Press = -1.27006348084736
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8579.353    -8579.353   -8660.5535   -8660.5535    314.25429    314.25429    23682.831    23682.831   -3307.6429   -3307.6429 
   14000    -8575.855    -8575.855   -8658.0264   -8658.0264    318.01209    318.01209    23652.882    23652.882    571.09075    571.09075 
Loop time of 32.3828 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.668 ns/day, 8.995 hours/ns, 30.881 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.791     | 31.791     | 31.791     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12987    | 0.12987    | 0.12987    |   0.0 |  0.40
Output  | 0.00015347 | 0.00015347 | 0.00015347 |   0.0 |  0.00
Modify  | 0.39555    | 0.39555    | 0.39555    |   0.0 |  1.22
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:        5361.00 ave        5361 max        5361 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326444.0 ave      326444 max      326444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326444
Ave neighs/atom = 163.22200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.9013012871, Press = -6.59105986210396
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8575.855    -8575.855   -8658.0264   -8658.0264    318.01209    318.01209    23652.882    23652.882    571.09075    571.09075 
   15000   -8581.3539   -8581.3539   -8660.8192   -8660.8192    307.53895    307.53895    23652.794    23652.794    728.31159    728.31159 
Loop time of 32.4836 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.660 ns/day, 9.023 hours/ns, 30.785 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.89      | 31.89      | 31.89      |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1306     | 0.1306     | 0.1306     |   0.0 |  0.40
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.39696    | 0.39696    | 0.39696    |   0.0 |  1.22
Other   |            | 0.06577    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5374.00 ave        5374 max        5374 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326992.0 ave      326992 max      326992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326992
Ave neighs/atom = 163.49600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.843309331075, Press = 1.98202626204379
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8581.3539   -8581.3539   -8660.8192   -8660.8192    307.53895    307.53895    23652.794    23652.794    728.31159    728.31159 
   16000   -8577.0917   -8577.0917    -8658.219    -8658.219    313.97132    313.97132    23684.285    23684.285    -1702.508    -1702.508 
Loop time of 32.2949 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.971 hours/ns, 30.965 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.695     | 31.695     | 31.695     |   0.0 | 98.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13098    | 0.13098    | 0.13098    |   0.0 |  0.41
Output  | 0.00015475 | 0.00015475 | 0.00015475 |   0.0 |  0.00
Modify  | 0.40183    | 0.40183    | 0.40183    |   0.0 |  1.24
Other   |            | 0.06655    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5374.00 ave        5374 max        5374 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326994.0 ave      326994 max      326994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326994
Ave neighs/atom = 163.49700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.901070022451, Press = -3.22215957375345
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.0917   -8577.0917    -8658.219    -8658.219    313.97132    313.97132    23684.285    23684.285    -1702.508    -1702.508 
   17000   -8579.2301   -8579.2301   -8657.8563   -8657.8563    304.29138    304.29138    23658.365    23658.365    525.51824    525.51824 
Loop time of 31.7986 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.833 hours/ns, 31.448 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.222     | 31.222     | 31.222     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12739    | 0.12739    | 0.12739    |   0.0 |  0.40
Output  | 0.0001527  | 0.0001527  | 0.0001527  |   0.0 |  0.00
Modify  | 0.38276    | 0.38276    | 0.38276    |   0.0 |  1.20
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:        5386.00 ave        5386 max        5386 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326520.0 ave      326520 max      326520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326520
Ave neighs/atom = 163.26000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.911236657526, Press = -9.20804781491569
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.2301   -8579.2301   -8657.8563   -8657.8563    304.29138    304.29138    23658.365    23658.365    525.51824    525.51824 
   18000   -8577.5089   -8577.5089   -8659.0209   -8659.0209    315.45956    315.45956    23611.329    23611.329    4637.5403    4637.5403 
Loop time of 31.4916 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.744 ns/day, 8.748 hours/ns, 31.755 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.929     | 30.929     | 30.929     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12514    | 0.12514    | 0.12514    |   0.0 |  0.40
Output  | 0.00015513 | 0.00015513 | 0.00015513 |   0.0 |  0.00
Modify  | 0.37215    | 0.37215    | 0.37215    |   0.0 |  1.18
Other   |            | 0.06533    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5370.00 ave        5370 max        5370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327046.0 ave      327046 max      327046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327046
Ave neighs/atom = 163.52300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.946068192226, Press = -5.84859338844344
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.5089   -8577.5089   -8659.0209   -8659.0209    315.45956    315.45956    23611.329    23611.329    4637.5403    4637.5403 
   19000   -8575.5692   -8575.5692   -8657.8662   -8657.8662    318.49812    318.49812    23654.967    23654.967    618.69085    618.69085 
Loop time of 31.9166 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.707 ns/day, 8.866 hours/ns, 31.332 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.334     | 31.334     | 31.334     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12847    | 0.12847    | 0.12847    |   0.0 |  0.40
Output  | 0.00015522 | 0.00015522 | 0.00015522 |   0.0 |  0.00
Modify  | 0.38729    | 0.38729    | 0.38729    |   0.0 |  1.21
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:        5364.00 ave        5364 max        5364 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327638.0 ave      327638 max      327638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327638
Ave neighs/atom = 163.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 = 312.001201140822, Press = 2.60916651838728
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8575.5692   -8575.5692   -8657.8662   -8657.8662    318.49812    318.49812    23654.967    23654.967    618.69085    618.69085 
   20000   -8581.4448   -8581.4448   -8661.2117   -8661.2117    308.70595    308.70595     23665.06     23665.06   -1105.5752   -1105.5752 
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.346     | 31.346     | 31.346     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12857    | 0.12857    | 0.12857    |   0.0 |  0.40
Output  | 0.00015476 | 0.00015476 | 0.00015476 |   0.0 |  0.00
Modify  | 0.39098    | 0.39098    | 0.39098    |   0.0 |  1.22
Other   |            | 0.06753    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326898.0 ave      326898 max      326898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326898
Ave neighs/atom = 163.44900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.953844769332, Press = -3.39886822781804
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8581.4448   -8581.4448   -8661.2117   -8661.2117    308.70595    308.70595     23665.06     23665.06   -1105.5752   -1105.5752 
   21000   -8577.7765   -8577.7765   -8659.9956   -8659.9956    318.19629    318.19629    23646.737    23646.737    778.61442    778.61442 
Loop time of 31.2658 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.763 ns/day, 8.685 hours/ns, 31.984 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.699     | 30.699     | 30.699     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12531    | 0.12531    | 0.12531    |   0.0 |  0.40
Output  | 0.0001555  | 0.0001555  | 0.0001555  |   0.0 |  0.00
Modify  | 0.37561    | 0.37561    | 0.37561    |   0.0 |  1.20
Other   |            | 0.06561    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5371.00 ave        5371 max        5371 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326816.0 ave      326816 max      326816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326816
Ave neighs/atom = 163.40800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.074808184616, Press = -0.344327375697336
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.7765   -8577.7765   -8659.9956   -8659.9956    318.19629    318.19629    23646.737    23646.737    778.61442    778.61442 
   22000   -8573.2359   -8573.2359   -8656.5245   -8656.5245    322.33571    322.33571    23654.955    23654.955    914.28143    914.28143 
Loop time of 31.3232 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.758 ns/day, 8.701 hours/ns, 31.925 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.755     | 30.755     | 30.755     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12564    | 0.12564    | 0.12564    |   0.0 |  0.40
Output  | 0.00015569 | 0.00015569 | 0.00015569 |   0.0 |  0.00
Modify  | 0.37663    | 0.37663    | 0.37663    |   0.0 |  1.20
Other   |            | 0.06536    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5374.00 ave        5374 max        5374 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326816.0 ave      326816 max      326816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326816
Ave neighs/atom = 163.40800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.188672548085, Press = 1.18113333752506
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8573.2359   -8573.2359   -8656.5245   -8656.5245    322.33571    322.33571    23654.955    23654.955    914.28143    914.28143 
   23000   -8577.9508   -8577.9508   -8657.8885   -8657.8885    309.36728    309.36728    23674.915    23674.915   -1370.3702   -1370.3702 
Loop time of 31.9 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.708 ns/day, 8.861 hours/ns, 31.348 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.326     | 31.326     | 31.326     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1271     | 0.1271     | 0.1271     |   0.0 |  0.40
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.38153    | 0.38153    | 0.38153    |   0.0 |  1.20
Other   |            | 0.06539    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5355.00 ave        5355 max        5355 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327108.0 ave      327108 max      327108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327108
Ave neighs/atom = 163.55400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.362961833872, Press = -1.83296496024946
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.9508   -8577.9508   -8657.8885   -8657.8885    309.36728    309.36728    23674.915    23674.915   -1370.3702   -1370.3702 
   24000   -8576.2201   -8576.2201   -8657.8773   -8657.8773    316.02182    316.02182    23631.791    23631.791    2649.9132    2649.9132 
Loop time of 31.1601 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.773 ns/day, 8.656 hours/ns, 32.092 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.601     | 30.601     | 30.601     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12497    | 0.12497    | 0.12497    |   0.0 |  0.40
Output  | 0.00015464 | 0.00015464 | 0.00015464 |   0.0 |  0.00
Modify  | 0.36891    | 0.36891    | 0.36891    |   0.0 |  1.18
Other   |            | 0.06521    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5373.00 ave        5373 max        5373 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326672.0 ave      326672 max      326672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326672
Ave neighs/atom = 163.33600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.301447525717, Press = -2.83204508200051
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.2201   -8576.2201   -8657.8773   -8657.8773    316.02182    316.02182    23631.791    23631.791    2649.9132    2649.9132 
   25000   -8578.8738   -8578.8738   -8658.0268   -8658.0268    306.33046    306.33046    23643.721    23643.721    1577.1244    1577.1244 
Loop time of 32.0579 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.695 ns/day, 8.905 hours/ns, 31.194 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.475     | 31.475     | 31.475     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12936    | 0.12936    | 0.12936    |   0.0 |  0.40
Output  | 0.00015471 | 0.00015471 | 0.00015471 |   0.0 |  0.00
Modify  | 0.38765    | 0.38765    | 0.38765    |   0.0 |  1.21
Other   |            | 0.06607    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5382.00 ave        5382 max        5382 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327464.0 ave      327464 max      327464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327464
Ave neighs/atom = 163.73200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.276832482056, Press = -1.15200249117231
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.8738   -8578.8738   -8658.0268   -8658.0268    306.33046    306.33046    23643.721    23643.721    1577.1244    1577.1244 
   26000   -8579.3519   -8579.3519    -8658.949    -8658.949    308.04878    308.04878    23647.931    23647.931    918.56577    918.56577 
Loop time of 31.7532 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.721 ns/day, 8.820 hours/ns, 31.493 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.177     | 31.177     | 31.177     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12788    | 0.12788    | 0.12788    |   0.0 |  0.40
Output  | 0.00038884 | 0.00038884 | 0.00038884 |   0.0 |  0.00
Modify  | 0.38209    | 0.38209    | 0.38209    |   0.0 |  1.20
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:        5361.00 ave        5361 max        5361 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327074.0 ave      327074 max      327074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327074
Ave neighs/atom = 163.53700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.221067178028, Press = -1.00970164251314
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.3519   -8579.3519    -8658.949    -8658.949    308.04878    308.04878    23647.931    23647.931    918.56577    918.56577 
   27000   -8579.5773   -8579.5773   -8659.2959   -8659.2959    308.51934    308.51934    23669.315    23669.315   -1951.5871   -1951.5871 
Loop time of 31.2783 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.762 ns/day, 8.688 hours/ns, 31.971 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.714     | 30.714     | 30.714     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12438    | 0.12438    | 0.12438    |   0.0 |  0.40
Output  | 0.00019791 | 0.00019791 | 0.00019791 |   0.0 |  0.00
Modify  | 0.37423    | 0.37423    | 0.37423    |   0.0 |  1.20
Other   |            | 0.06507    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5354.00 ave        5354 max        5354 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327298.0 ave      327298 max      327298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327298
Ave neighs/atom = 163.64900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.242357510796, Press = 1.78420098639294
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.5773   -8579.5773   -8659.2959   -8659.2959    308.51934    308.51934    23669.315    23669.315   -1951.5871   -1951.5871 
   28000   -8574.8243   -8574.8243   -8656.2332   -8656.2332    315.06063    315.06063    23701.162    23701.162   -3535.5458   -3535.5458 
Loop time of 31.7185 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.724 ns/day, 8.811 hours/ns, 31.527 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.139     | 31.139     | 31.139     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12813    | 0.12813    | 0.12813    |   0.0 |  0.40
Output  | 0.00019959 | 0.00019959 | 0.00019959 |   0.0 |  0.00
Modify  | 0.38554    | 0.38554    | 0.38554    |   0.0 |  1.22
Other   |            | 0.06552    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5383.00 ave        5383 max        5383 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326872.0 ave      326872 max      326872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326872
Ave neighs/atom = 163.43600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.344558491554, Press = -5.24604561132191
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8574.8243   -8574.8243   -8656.2332   -8656.2332    315.06063    315.06063    23701.162    23701.162   -3535.5458   -3535.5458 
   29000   -8577.1689   -8577.1689   -8658.6822   -8658.6822    315.46487    315.46487    23644.413    23644.413    2205.2557    2205.2557 
Loop time of 31.9588 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.703 ns/day, 8.877 hours/ns, 31.290 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.373     | 31.373     | 31.373     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12912    | 0.12912    | 0.12912    |   0.0 |  0.40
Output  | 0.00019158 | 0.00019158 | 0.00019158 |   0.0 |  0.00
Modify  | 0.38971    | 0.38971    | 0.38971    |   0.0 |  1.22
Other   |            | 0.06626    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5383.00 ave        5383 max        5383 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326486.0 ave      326486 max      326486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326486
Ave neighs/atom = 163.24300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.42877267145, Press = -3.73875483624594
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.1689   -8577.1689   -8658.6822   -8658.6822    315.46487    315.46487    23644.413    23644.413    2205.2557    2205.2557 
   30000   -8576.7492   -8576.7492     -8656.87     -8656.87    310.07583    310.07583    23660.052    23660.052    502.87765    502.87765 
Loop time of 31.8182 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.715 ns/day, 8.838 hours/ns, 31.429 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.246     | 31.246     | 31.246     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12717    | 0.12717    | 0.12717    |   0.0 |  0.40
Output  | 0.00015451 | 0.00015451 | 0.00015451 |   0.0 |  0.00
Modify  | 0.37977    | 0.37977    | 0.37977    |   0.0 |  1.19
Other   |            | 0.06552    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5381.00 ave        5381 max        5381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327326.0 ave      327326 max      327326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327326
Ave neighs/atom = 163.66300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.569733642127, Press = -0.847874904327119
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.7492   -8576.7492     -8656.87     -8656.87    310.07583    310.07583    23660.052    23660.052    502.87765    502.87765 
   31000    -8575.347    -8575.347   -8658.6029   -8658.6029    322.20883    322.20883    23684.001    23684.001   -2407.4553   -2407.4553 
Loop time of 32.2825 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.676 ns/day, 8.967 hours/ns, 30.977 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.689     | 31.689     | 31.689     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1305     | 0.1305     | 0.1305     |   0.0 |  0.40
Output  | 0.00015359 | 0.00015359 | 0.00015359 |   0.0 |  0.00
Modify  | 0.39572    | 0.39572    | 0.39572    |   0.0 |  1.23
Other   |            | 0.06735    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5373.00 ave        5373 max        5373 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327062.0 ave      327062 max      327062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327062
Ave neighs/atom = 163.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 = 312.582828125413, Press = -2.57498387498655
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8575.347    -8575.347   -8658.6029   -8658.6029    322.20883    322.20883    23684.001    23684.001   -2407.4553   -2407.4553 
   32000   -8578.1703   -8578.1703   -8658.4264   -8658.4264    310.59945    310.59945    23619.029    23619.029    3963.8831    3963.8831 
Loop time of 31.1689 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.772 ns/day, 8.658 hours/ns, 32.083 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.604     | 30.604     | 30.604     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12497    | 0.12497    | 0.12497    |   0.0 |  0.40
Output  | 0.00019178 | 0.00019178 | 0.00019178 |   0.0 |  0.00
Modify  | 0.37375    | 0.37375    | 0.37375    |   0.0 |  1.20
Other   |            | 0.06568    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5364.00 ave        5364 max        5364 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326600.0 ave      326600 max      326600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326600
Ave neighs/atom = 163.30000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.548491840889, Press = -3.71779220784769
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.1703   -8578.1703   -8658.4264   -8658.4264    310.59945    310.59945    23619.029    23619.029    3963.8831    3963.8831 
   33000   -8577.0919   -8577.0919   -8657.3443   -8657.3443    310.58488    310.58488    23667.668    23667.668    371.65876    371.65876 
Loop time of 31.6414 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.731 ns/day, 8.789 hours/ns, 31.604 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.06      | 31.06      | 31.06      |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12816    | 0.12816    | 0.12816    |   0.0 |  0.41
Output  | 0.00015432 | 0.00015432 | 0.00015432 |   0.0 |  0.00
Modify  | 0.38676    | 0.38676    | 0.38676    |   0.0 |  1.22
Other   |            | 0.06591    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327764.0 ave      327764 max      327764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327764
Ave neighs/atom = 163.88200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.547016239653, Press = -0.253246849665492
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.0919   -8577.0919   -8657.3443   -8657.3443    310.58488    310.58488    23667.668    23667.668    371.65876    371.65876 
   34000   -8579.5657   -8579.5657   -8658.2472   -8658.2472    304.50554    304.50554    23644.862    23644.862     948.2758     948.2758 
Loop time of 31.206 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.769 ns/day, 8.668 hours/ns, 32.045 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.643     | 30.643     | 30.643     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12516    | 0.12516    | 0.12516    |   0.0 |  0.40
Output  | 0.00015078 | 0.00015078 | 0.00015078 |   0.0 |  0.00
Modify  | 0.37229    | 0.37229    | 0.37229    |   0.0 |  1.19
Other   |            | 0.06532    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5366.00 ave        5366 max        5366 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326996.0 ave      326996 max      326996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326996
Ave neighs/atom = 163.49800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.530108774611, Press = -0.779714190257871
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.5657   -8579.5657   -8658.2472   -8658.2472    304.50554    304.50554    23644.862    23644.862     948.2758     948.2758 
   35000    -8574.311    -8574.311   -8654.9423   -8654.9423    312.05146    312.05146    23648.557    23648.557    2149.3304    2149.3304 
Loop time of 31.7484 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.721 ns/day, 8.819 hours/ns, 31.498 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.17      | 31.17      | 31.17      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1276     | 0.1276     | 0.1276     |   0.0 |  0.40
Output  | 0.00015647 | 0.00015647 | 0.00015647 |   0.0 |  0.00
Modify  | 0.38481    | 0.38481    | 0.38481    |   0.0 |  1.21
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:        5365.00 ave        5365 max        5365 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327136.0 ave      327136 max      327136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327136
Ave neighs/atom = 163.56800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.638657512009, Press = -2.56530583546951
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8574.311    -8574.311   -8654.9423   -8654.9423    312.05146    312.05146    23648.557    23648.557    2149.3304    2149.3304 
   36000   -8576.0739   -8576.0739   -8658.1697   -8658.1697    317.71901    317.71901    23649.189    23649.189    1874.8097    1874.8097 
Loop time of 31.4016 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.751 ns/day, 8.723 hours/ns, 31.845 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.83      | 30.83      | 30.83      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12619    | 0.12619    | 0.12619    |   0.0 |  0.40
Output  | 0.00015484 | 0.00015484 | 0.00015484 |   0.0 |  0.00
Modify  | 0.37912    | 0.37912    | 0.37912    |   0.0 |  1.21
Other   |            | 0.06604    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327184.0 ave      327184 max      327184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327184
Ave neighs/atom = 163.59200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.696476240251, Press = 0.836866937392901
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.0739   -8576.0739   -8658.1697   -8658.1697    317.71901    317.71901    23649.189    23649.189    1874.8097    1874.8097 
   37000   -8580.3611   -8580.3611   -8660.0169   -8660.0169    308.27598    308.27598    23660.222    23660.222   -722.94871   -722.94871 
Loop time of 31.5273 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.758 hours/ns, 31.719 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.956     | 30.956     | 30.956     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12604    | 0.12604    | 0.12604    |   0.0 |  0.40
Output  | 0.00015171 | 0.00015171 | 0.00015171 |   0.0 |  0.00
Modify  | 0.37901    | 0.37901    | 0.37901    |   0.0 |  1.20
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:        5389.00 ave        5389 max        5389 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327050.0 ave      327050 max      327050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327050
Ave neighs/atom = 163.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 = 312.732623394203, Press = -0.562532314318521
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.3611   -8580.3611   -8660.0169   -8660.0169    308.27598    308.27598    23660.222    23660.222   -722.94871   -722.94871 
   38000   -8576.4094   -8576.4094   -8656.5279   -8656.5279    310.06694    310.06694    23679.987    23679.987   -2517.0089   -2517.0089 
Loop time of 31.0108 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.786 ns/day, 8.614 hours/ns, 32.247 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.449     | 30.449     | 30.449     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12472    | 0.12472    | 0.12472    |   0.0 |  0.40
Output  | 0.00015282 | 0.00015282 | 0.00015282 |   0.0 |  0.00
Modify  | 0.37117    | 0.37117    | 0.37117    |   0.0 |  1.20
Other   |            | 0.0654     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5382.00 ave        5382 max        5382 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327128.0 ave      327128 max      327128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327128
Ave neighs/atom = 163.56400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.698000517935, Press = -2.27569998696624
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.4094   -8576.4094   -8656.5279   -8656.5279    310.06694    310.06694    23679.987    23679.987   -2517.0089   -2517.0089 
   39000   -8580.5664   -8580.5664   -8659.5742   -8659.5742     305.7684     305.7684    23638.428    23638.428    2810.0795    2810.0795 
Loop time of 31.0052 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.787 ns/day, 8.613 hours/ns, 32.253 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.443     | 30.443     | 30.443     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12398    | 0.12398    | 0.12398    |   0.0 |  0.40
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.37243    | 0.37243    | 0.37243    |   0.0 |  1.20
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:        5366.00 ave        5366 max        5366 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326912.0 ave      326912 max      326912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326912
Ave neighs/atom = 163.45600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.630316532412, Press = -1.55063449012826
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.5664   -8580.5664   -8659.5742   -8659.5742     305.7684     305.7684    23638.428    23638.428    2810.0795    2810.0795 
   40000   -8576.3973   -8576.3973   -8657.6649   -8657.6649    314.51401    314.51401    23654.561    23654.561     48.09027     48.09027 
Loop time of 31.715 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.724 ns/day, 8.810 hours/ns, 31.531 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.135     | 31.135     | 31.135     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12827    | 0.12827    | 0.12827    |   0.0 |  0.40
Output  | 0.00015295 | 0.00015295 | 0.00015295 |   0.0 |  0.00
Modify  | 0.38477    | 0.38477    | 0.38477    |   0.0 |  1.21
Other   |            | 0.06671    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5377.00 ave        5377 max        5377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327228.0 ave      327228 max      327228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327228
Ave neighs/atom = 163.61400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.626539684715, Press = 0.0601349655703958
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.3973   -8576.3973   -8657.6649   -8657.6649    314.51401    314.51401    23654.561    23654.561     48.09027     48.09027 
   41000   -8579.0678   -8579.0678   -8660.6843   -8660.6843    315.86434    315.86434     23674.99     23674.99   -1565.5267   -1565.5267 
Loop time of 31.2907 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.761 ns/day, 8.692 hours/ns, 31.958 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.728     | 30.728     | 30.728     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12432    | 0.12432    | 0.12432    |   0.0 |  0.40
Output  | 0.00015317 | 0.00015317 | 0.00015317 |   0.0 |  0.00
Modify  | 0.37251    | 0.37251    | 0.37251    |   0.0 |  1.19
Other   |            | 0.06571    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327100.0 ave      327100 max      327100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327100
Ave neighs/atom = 163.55000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.580235206123, Press = -1.7669310244145
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.0678   -8579.0678   -8660.6843   -8660.6843    315.86434    315.86434     23674.99     23674.99   -1565.5267   -1565.5267 
   42000   -8575.9668   -8575.9668   -8656.4662   -8656.4662    311.54114    311.54114    23672.149    23672.149   -970.35308   -970.35308 
Loop time of 31.3251 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.758 ns/day, 8.701 hours/ns, 31.923 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.755     | 30.755     | 30.755     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12604    | 0.12604    | 0.12604    |   0.0 |  0.40
Output  | 0.00019493 | 0.00019493 | 0.00019493 |   0.0 |  0.00
Modify  | 0.37788    | 0.37788    | 0.37788    |   0.0 |  1.21
Other   |            | 0.06592    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5388.00 ave        5388 max        5388 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326558.0 ave      326558 max      326558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326558
Ave neighs/atom = 163.27900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.544812040098, Press = -1.03549744350948
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8575.9668   -8575.9668   -8656.4662   -8656.4662    311.54114    311.54114    23672.149    23672.149   -970.35308   -970.35308 
   43000   -8581.6554   -8581.6554   -8659.9894   -8659.9894    303.16088    303.16088    23666.215    23666.215   -1946.4902   -1946.4902 
Loop time of 31.9325 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.706 ns/day, 8.870 hours/ns, 31.316 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.344     | 31.344     | 31.344     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12836    | 0.12836    | 0.12836    |   0.0 |  0.40
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.39321    | 0.39321    | 0.39321    |   0.0 |  1.23
Other   |            | 0.06659    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5370.00 ave        5370 max        5370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326688.0 ave      326688 max      326688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326688
Ave neighs/atom = 163.34400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.525322787035, Press = -0.906791442587564
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8581.6554   -8581.6554   -8659.9894   -8659.9894    303.16088    303.16088    23666.215    23666.215   -1946.4902   -1946.4902 
   44000   -8576.7031   -8576.7031   -8657.0307   -8657.0307    310.87642    310.87642    23620.361    23620.361    4219.6927    4219.6927 
Loop time of 31.0341 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.784 ns/day, 8.621 hours/ns, 32.223 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.475     | 30.475     | 30.475     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1241     | 0.1241     | 0.1241     |   0.0 |  0.40
Output  | 0.00015446 | 0.00015446 | 0.00015446 |   0.0 |  0.00
Modify  | 0.36996    | 0.36996    | 0.36996    |   0.0 |  1.19
Other   |            | 0.06471    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326746.0 ave      326746 max      326746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326746
Ave neighs/atom = 163.37300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.479903390213, Press = 0.020545020104473
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.7031   -8576.7031   -8657.0307   -8657.0307    310.87642    310.87642    23620.361    23620.361    4219.6927    4219.6927 
   45000   -8583.3376   -8583.3376   -8662.6572   -8662.6572    306.97507    306.97507     23639.08     23639.08    444.89171    444.89171 
Loop time of 31.5789 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.736 ns/day, 8.772 hours/ns, 31.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    | 31.007     | 31.007     | 31.007     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1269     | 0.1269     | 0.1269     |   0.0 |  0.40
Output  | 0.00015369 | 0.00015369 | 0.00015369 |   0.0 |  0.00
Modify  | 0.37994    | 0.37994    | 0.37994    |   0.0 |  1.20
Other   |            | 0.06534    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327782.0 ave      327782 max      327782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327782
Ave neighs/atom = 163.89100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.462431525383, Press = -1.62992207919248
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8583.3376   -8583.3376   -8662.6572   -8662.6572    306.97507    306.97507     23639.08     23639.08    444.89171    444.89171 
   46000    -8577.713    -8577.713   -8658.3067   -8658.3067    311.90624    311.90624     23657.38     23657.38   -37.855595   -37.855595 
Loop time of 31.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.762 ns/day, 8.690 hours/ns, 31.964 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.718     | 30.718     | 30.718     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12598    | 0.12598    | 0.12598    |   0.0 |  0.40
Output  | 0.00015476 | 0.00015476 | 0.00015476 |   0.0 |  0.00
Modify  | 0.37557    | 0.37557    | 0.37557    |   0.0 |  1.20
Other   |            | 0.06534    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5389.00 ave        5389 max        5389 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327252.0 ave      327252 max      327252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327252
Ave neighs/atom = 163.62600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.401412627662, Press = -0.0602504397050974
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8577.713    -8577.713   -8658.3067   -8658.3067    311.90624    311.90624     23657.38     23657.38   -37.855595   -37.855595 
   47000   -8580.7973   -8580.7973   -8660.0897   -8660.0897    306.86954    306.86954    23701.908    23701.908   -4260.8128   -4260.8128 
Loop time of 31.1262 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.776 ns/day, 8.646 hours/ns, 32.127 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.559     | 30.559     | 30.559     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12637    | 0.12637    | 0.12637    |   0.0 |  0.41
Output  | 0.00015598 | 0.00015598 | 0.00015598 |   0.0 |  0.00
Modify  | 0.3748     | 0.3748     | 0.3748     |   0.0 |  1.20
Other   |            | 0.06603    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5395.00 ave        5395 max        5395 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327058.0 ave      327058 max      327058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327058
Ave neighs/atom = 163.52900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.396279460573, Press = -0.956491635671967
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.7973   -8580.7973   -8660.0897   -8660.0897    306.86954    306.86954    23701.908    23701.908   -4260.8128   -4260.8128 
   48000   -8577.2944   -8577.2944   -8655.6963   -8655.6963    303.42358    303.42358    23631.438    23631.438    3567.6772    3567.6772 
Loop time of 31.939 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.705 ns/day, 8.872 hours/ns, 31.310 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.36      | 31.36      | 31.36      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12792    | 0.12792    | 0.12792    |   0.0 |  0.40
Output  | 0.00018887 | 0.00018887 | 0.00018887 |   0.0 |  0.00
Modify  | 0.38424    | 0.38424    | 0.38424    |   0.0 |  1.20
Other   |            | 0.06615    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326282.0 ave      326282 max      326282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326282
Ave neighs/atom = 163.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.403683267845, Press = -0.905464467700095
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.2944   -8577.2944   -8655.6963   -8655.6963    303.42358    303.42358    23631.438    23631.438    3567.6772    3567.6772 
   49000   -8574.9359   -8574.9359   -8657.0022   -8657.0022    317.60521    317.60521     23656.31     23656.31    1589.2092    1589.2092 
Loop time of 31.0175 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.786 ns/day, 8.616 hours/ns, 32.240 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.456     | 30.456     | 30.456     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12423    | 0.12423    | 0.12423    |   0.0 |  0.40
Output  | 0.00019917 | 0.00019917 | 0.00019917 |   0.0 |  0.00
Modify  | 0.37162    | 0.37162    | 0.37162    |   0.0 |  1.20
Other   |            | 0.06509    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327670.0 ave      327670 max      327670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327670
Ave neighs/atom = 163.83500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.430865783612, Press = -1.58913427837236
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8574.9359   -8574.9359   -8657.0022   -8657.0022    317.60521    317.60521     23656.31     23656.31    1589.2092    1589.2092 
   50000    -8577.279    -8577.279   -8656.3606   -8656.3606    306.05392    306.05392    23660.389    23660.389    517.26108    517.26108 
Loop time of 30.9678 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.790 ns/day, 8.602 hours/ns, 32.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    | 30.408     | 30.408     | 30.408     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12372    | 0.12372    | 0.12372    |   0.0 |  0.40
Output  | 0.00015427 | 0.00015427 | 0.00015427 |   0.0 |  0.00
Modify  | 0.37067    | 0.37067    | 0.37067    |   0.0 |  1.20
Other   |            | 0.06504    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5356.00 ave        5356 max        5356 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327058.0 ave      327058 max      327058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327058
Ave neighs/atom = 163.52900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.517883364894, Press = -0.605035391777125
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8577.279    -8577.279   -8656.3606   -8656.3606    306.05392    306.05392    23660.389    23660.389    517.26108    517.26108 
   51000    -8573.785    -8573.785   -8656.8984   -8656.8984    321.65763    321.65763    23683.748    23683.748   -1421.3729   -1421.3729 
Loop time of 31.4968 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.743 ns/day, 8.749 hours/ns, 31.749 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.924     | 30.924     | 30.924     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12681    | 0.12681    | 0.12681    |   0.0 |  0.40
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.38007    | 0.38007    | 0.38007    |   0.0 |  1.21
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:        5391.00 ave        5391 max        5391 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327094.0 ave      327094 max      327094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327094
Ave neighs/atom = 163.54700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.552902674374, Press = -0.0363429277349306
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8573.785    -8573.785   -8656.8984   -8656.8984    321.65763    321.65763    23683.748    23683.748   -1421.3729   -1421.3729 
   52000   -8578.2879   -8578.2879   -8659.1843   -8659.1843    313.07735    313.07735    23661.252    23661.252   -990.73745   -990.73745 
Loop time of 31.1752 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.771 ns/day, 8.660 hours/ns, 32.077 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.612     | 30.612     | 30.612     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12499    | 0.12499    | 0.12499    |   0.0 |  0.40
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.37252    | 0.37252    | 0.37252    |   0.0 |  1.19
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:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326704.0 ave      326704 max      326704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326704
Ave neighs/atom = 163.35200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.59101248777, Press = -1.457767268748
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.2879   -8578.2879   -8659.1843   -8659.1843    313.07735    313.07735    23661.252    23661.252   -990.73745   -990.73745 
   53000   -8574.9256   -8574.9256   -8656.4144   -8656.4144    315.37005    315.37005    23663.525    23663.525    1404.0921    1404.0921 
Loop time of 31.2279 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.767 ns/day, 8.674 hours/ns, 32.023 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.66      | 30.66      | 30.66      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12628    | 0.12628    | 0.12628    |   0.0 |  0.40
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.37622    | 0.37622    | 0.37622    |   0.0 |  1.20
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:        5387.00 ave        5387 max        5387 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326986.0 ave      326986 max      326986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326986
Ave neighs/atom = 163.49300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.594181827342, Press = -1.84665263003269
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8574.9256   -8574.9256   -8656.4144   -8656.4144    315.37005    315.37005    23663.525    23663.525    1404.0921    1404.0921 
   54000   -8576.7507   -8576.7507   -8658.6428   -8658.6428    316.93092    316.93092    23653.664    23653.664     1184.578     1184.578 
Loop time of 31.0081 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.786 ns/day, 8.613 hours/ns, 32.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    | 30.446     | 30.446     | 30.446     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12573    | 0.12573    | 0.12573    |   0.0 |  0.41
Output  | 0.00015499 | 0.00015499 | 0.00015499 |   0.0 |  0.00
Modify  | 0.37072    | 0.37072    | 0.37072    |   0.0 |  1.20
Other   |            | 0.06534    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326790.0 ave      326790 max      326790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326790
Ave neighs/atom = 163.39500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.612333427137, Press = 0.54493136475983
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.7507   -8576.7507   -8658.6428   -8658.6428    316.93092    316.93092    23653.664    23653.664     1184.578     1184.578 
   55000    -8578.472    -8578.472   -8658.2474   -8658.2474    308.73894    308.73894    23672.753    23672.753    -2032.737    -2032.737 
Loop time of 31.6023 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.778 hours/ns, 31.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    | 31.023     | 31.023     | 31.023     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12832    | 0.12832    | 0.12832    |   0.0 |  0.41
Output  | 0.00016119 | 0.00016119 | 0.00016119 |   0.0 |  0.00
Modify  | 0.38513    | 0.38513    | 0.38513    |   0.0 |  1.22
Other   |            | 0.06617    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5386.00 ave        5386 max        5386 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326870.0 ave      326870 max      326870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326870
Ave neighs/atom = 163.43500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.682882103923, Press = 0.0314999902142796
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8578.472    -8578.472   -8658.2474   -8658.2474    308.73894    308.73894    23672.753    23672.753    -2032.737    -2032.737 
   56000   -8573.8128   -8573.8128   -8657.2232   -8657.2232    322.80692    322.80692    23654.546    23654.546    803.46631    803.46631 
Loop time of 31.9395 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.705 ns/day, 8.872 hours/ns, 31.309 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.36      | 31.36      | 31.36      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12831    | 0.12831    | 0.12831    |   0.0 |  0.40
Output  | 0.0001579  | 0.0001579  | 0.0001579  |   0.0 |  0.00
Modify  | 0.38511    | 0.38511    | 0.38511    |   0.0 |  1.21
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:        5362.00 ave        5362 max        5362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326862.0 ave      326862 max      326862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326862
Ave neighs/atom = 163.43100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.726181232592, Press = -1.59880436663665
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8573.8128   -8573.8128   -8657.2232   -8657.2232    322.80692    322.80692    23654.546    23654.546    803.46631    803.46631 
   57000   -8578.6775   -8578.6775   -8660.8056   -8660.8056    317.84428    317.84428    23669.861    23669.861    424.36087    424.36087 
Loop time of 31.7488 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.721 ns/day, 8.819 hours/ns, 31.497 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.172     | 31.172     | 31.172     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12672    | 0.12672    | 0.12672    |   0.0 |  0.40
Output  | 0.0001548  | 0.0001548  | 0.0001548  |   0.0 |  0.00
Modify  | 0.38448    | 0.38448    | 0.38448    |   0.0 |  1.21
Other   |            | 0.06586    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5362.00 ave        5362 max        5362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327186.0 ave      327186 max      327186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327186
Ave neighs/atom = 163.59300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.739245681034, Press = -1.69635652006945
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.6775   -8578.6775   -8660.8056   -8660.8056    317.84428    317.84428    23669.861    23669.861    424.36087    424.36087 
   58000   -8578.9675   -8578.9675   -8657.8198   -8657.8198    305.16654    305.16654    23673.093    23673.093    98.193601    98.193601 
Loop time of 30.8767 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.798 ns/day, 8.577 hours/ns, 32.387 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.318     | 30.318     | 30.318     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12367    | 0.12367    | 0.12367    |   0.0 |  0.40
Output  | 0.00019683 | 0.00019683 | 0.00019683 |   0.0 |  0.00
Modify  | 0.36911    | 0.36911    | 0.36911    |   0.0 |  1.20
Other   |            | 0.06556    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5371.00 ave        5371 max        5371 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327434.0 ave      327434 max      327434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327434
Ave neighs/atom = 163.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 = 312.801859764885, Press = -0.723279845655575
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.9675   -8578.9675   -8657.8198   -8657.8198    305.16654    305.16654    23673.093    23673.093    98.193601    98.193601 
   59000   -8576.9473   -8576.9473    -8658.884    -8658.884    317.10354    317.10354    23688.285    23688.285   -1057.3853   -1057.3853 
Loop time of 31.4395 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.748 ns/day, 8.733 hours/ns, 31.807 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.868     | 30.868     | 30.868     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12593    | 0.12593    | 0.12593    |   0.0 |  0.40
Output  | 0.00016307 | 0.00016307 | 0.00016307 |   0.0 |  0.00
Modify  | 0.37897    | 0.37897    | 0.37897    |   0.0 |  1.21
Other   |            | 0.06622    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5376.00 ave        5376 max        5376 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327574.0 ave      327574 max      327574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327574
Ave neighs/atom = 163.78700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.804271965069, Press = -2.74776499230907
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.9473   -8576.9473    -8658.884    -8658.884    317.10354    317.10354    23688.285    23688.285   -1057.3853   -1057.3853 
   60000   -8578.8236   -8578.8236   -8657.2829   -8657.2829    303.64563    303.64563    23648.175    23648.175    2650.3564    2650.3564 
Loop time of 30.6819 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.816 ns/day, 8.523 hours/ns, 32.593 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.126     | 30.126     | 30.126     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12353    | 0.12353    | 0.12353    |   0.0 |  0.40
Output  | 0.00015728 | 0.00015728 | 0.00015728 |   0.0 |  0.00
Modify  | 0.36714    | 0.36714    | 0.36714    |   0.0 |  1.20
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:        5366.00 ave        5366 max        5366 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326948.0 ave      326948 max      326948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326948
Ave neighs/atom = 163.47400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.838930905297, Press = 0.192207055071504
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.8236   -8578.8236   -8657.2829   -8657.2829    303.64563    303.64563    23648.175    23648.175    2650.3564    2650.3564 
   61000   -8577.2821   -8577.2821   -8657.5078   -8657.5078    310.48172    310.48172    23705.611    23705.611   -2192.9913   -2192.9913 
Loop time of 31.7217 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.724 ns/day, 8.812 hours/ns, 31.524 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.14      | 31.14      | 31.14      |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12818    | 0.12818    | 0.12818    |   0.0 |  0.40
Output  | 0.00015494 | 0.00015494 | 0.00015494 |   0.0 |  0.00
Modify  | 0.38774    | 0.38774    | 0.38774    |   0.0 |  1.22
Other   |            | 0.06577    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5370.00 ave        5370 max        5370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327844.0 ave      327844 max      327844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327844
Ave neighs/atom = 163.92200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.900426008847, Press = -1.58363328300061
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.2821   -8577.2821   -8657.5078   -8657.5078    310.48172    310.48172    23705.611    23705.611   -2192.9913   -2192.9913 
   62000   -8577.6099   -8577.6099   -8660.9092   -8660.9092    322.37698    322.37698    23661.715    23661.715    926.53889    926.53889 
Loop time of 30.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.812 ns/day, 8.536 hours/ns, 32.544 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.169     | 30.169     | 30.169     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12366    | 0.12366    | 0.12366    |   0.0 |  0.40
Output  | 0.00015589 | 0.00015589 | 0.00015589 |   0.0 |  0.00
Modify  | 0.36949    | 0.36949    | 0.36949    |   0.0 |  1.20
Other   |            | 0.06521    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5376.00 ave        5376 max        5376 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327026.0 ave      327026 max      327026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327026
Ave neighs/atom = 163.51300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.910775946239, Press = -1.37045765105027
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.6099   -8577.6099   -8660.9092   -8660.9092    322.37698    322.37698    23661.715    23661.715    926.53889    926.53889 
   63000   -8582.5346   -8582.5346   -8662.1889   -8662.1889    308.27049    308.27049     23638.86     23638.86    2566.8396    2566.8396 
Loop time of 31.2122 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.768 ns/day, 8.670 hours/ns, 32.039 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.643     | 30.643     | 30.643     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12584    | 0.12584    | 0.12584    |   0.0 |  0.40
Output  | 0.00015166 | 0.00015166 | 0.00015166 |   0.0 |  0.00
Modify  | 0.3775     | 0.3775     | 0.3775     |   0.0 |  1.21
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:        5377.00 ave        5377 max        5377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327466.0 ave      327466 max      327466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327466
Ave neighs/atom = 163.73300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.88758070394, Press = 0.0475170168963198
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8582.5346   -8582.5346   -8662.1889   -8662.1889    308.27049    308.27049     23638.86     23638.86    2566.8396    2566.8396 
   64000   -8577.8843   -8577.8843   -8659.0789   -8659.0789    314.23187    314.23187    23681.667    23681.667   -1112.4339   -1112.4339 
Loop time of 31.0714 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.781 ns/day, 8.631 hours/ns, 32.184 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.51      | 30.51      | 30.51      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12409    | 0.12409    | 0.12409    |   0.0 |  0.40
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.37249    | 0.37249    | 0.37249    |   0.0 |  1.20
Other   |            | 0.06518    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5379.00 ave        5379 max        5379 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327792.0 ave      327792 max      327792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327792
Ave neighs/atom = 163.89600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.88230642432, Press = -0.301386661969297
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.8843   -8577.8843   -8659.0789   -8659.0789    314.23187    314.23187    23681.667    23681.667   -1112.4339   -1112.4339 
   65000   -8577.6142   -8577.6142   -8658.4436   -8658.4436    312.81819    312.81819    23687.743    23687.743   -1828.2232   -1828.2232 
Loop time of 30.8975 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.796 ns/day, 8.583 hours/ns, 32.365 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.338     | 30.338     | 30.338     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12416    | 0.12416    | 0.12416    |   0.0 |  0.40
Output  | 0.00020716 | 0.00020716 | 0.00020716 |   0.0 |  0.00
Modify  | 0.36985    | 0.36985    | 0.36985    |   0.0 |  1.20
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:        5377.00 ave        5377 max        5377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327076.0 ave      327076 max      327076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327076
Ave neighs/atom = 163.53800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.86627300393, Press = -1.00932268083897
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.6142   -8577.6142   -8658.4436   -8658.4436    312.81819    312.81819    23687.743    23687.743   -1828.2232   -1828.2232 
   66000   -8579.4333   -8579.4333   -8659.8884   -8659.8884    311.36931    311.36931    23669.992    23669.992    483.22387    483.22387 
Loop time of 31.9101 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.708 ns/day, 8.864 hours/ns, 31.338 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.331     | 31.331     | 31.331     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12781    | 0.12781    | 0.12781    |   0.0 |  0.40
Output  | 0.00015471 | 0.00015471 | 0.00015471 |   0.0 |  0.00
Modify  | 0.38483    | 0.38483    | 0.38483    |   0.0 |  1.21
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:        5360.00 ave        5360 max        5360 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327138.0 ave      327138 max      327138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327138
Ave neighs/atom = 163.56900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869892612097, Press = -2.2788148086404
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.4333   -8579.4333   -8659.8884   -8659.8884    311.36931    311.36931    23669.992    23669.992    483.22387    483.22387 
   67000   -8577.2754   -8577.2754   -8660.1103   -8660.1103    320.57941    320.57941    23676.439    23676.439    247.78553    247.78553 
Loop time of 31.2739 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.763 ns/day, 8.687 hours/ns, 31.975 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.704     | 30.704     | 30.704     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12578    | 0.12578    | 0.12578    |   0.0 |  0.40
Output  | 0.00015313 | 0.00015313 | 0.00015313 |   0.0 |  0.00
Modify  | 0.37861    | 0.37861    | 0.37861    |   0.0 |  1.21
Other   |            | 0.06552    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5356.00 ave        5356 max        5356 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327258.0 ave      327258 max      327258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327258
Ave neighs/atom = 163.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 = 312.852708074852, Press = -0.212524783987882
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.2754   -8577.2754   -8660.1103   -8660.1103    320.57941    320.57941    23676.439    23676.439    247.78553    247.78553 
   68000    -8582.849    -8582.849   -8661.9776   -8661.9776    306.23599    306.23599    23697.345    23697.345   -3273.7835   -3273.7835 
Loop time of 31.0955 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.779 ns/day, 8.638 hours/ns, 32.159 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.526     | 30.526     | 30.526     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.40
Output  | 0.00019865 | 0.00019865 | 0.00019865 |   0.0 |  0.00
Modify  | 0.37854    | 0.37854    | 0.37854    |   0.0 |  1.22
Other   |            | 0.06539    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5384.00 ave        5384 max        5384 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327342.0 ave      327342 max      327342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327342
Ave neighs/atom = 163.67100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.81771466975, Press = 0.27606176061748
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8582.849    -8582.849   -8661.9776   -8661.9776    306.23599    306.23599    23697.345    23697.345   -3273.7835   -3273.7835 
   69000   -8577.6967   -8577.6967   -8658.7211   -8658.7211    313.57292    313.57292    23691.035    23691.035   -1249.3721   -1249.3721 
Loop time of 31.8718 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.853 hours/ns, 31.376 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.286     | 31.286     | 31.286     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12822    | 0.12822    | 0.12822    |   0.0 |  0.40
Output  | 0.00019196 | 0.00019196 | 0.00019196 |   0.0 |  0.00
Modify  | 0.39137    | 0.39137    | 0.39137    |   0.0 |  1.23
Other   |            | 0.06604    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5361.00 ave        5361 max        5361 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326822.0 ave      326822 max      326822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326822
Ave neighs/atom = 163.41100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.812793678714, Press = -1.08696440105438
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.6967   -8577.6967   -8658.7211   -8658.7211    313.57292    313.57292    23691.035    23691.035   -1249.3721   -1249.3721 
   70000   -8576.7565   -8576.7565   -8658.8201   -8658.8201    317.59425    317.59425    23649.471    23649.471    2666.0644    2666.0644 
Loop time of 31.7054 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.725 ns/day, 8.807 hours/ns, 31.540 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.128     | 31.128     | 31.128     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12726    | 0.12726    | 0.12726    |   0.0 |  0.40
Output  | 0.00015852 | 0.00015852 | 0.00015852 |   0.0 |  0.00
Modify  | 0.38397    | 0.38397    | 0.38397    |   0.0 |  1.21
Other   |            | 0.06634    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327042.0 ave      327042 max      327042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327042
Ave neighs/atom = 163.52100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.805483286798, Press = -0.683411315927271
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.7565   -8576.7565   -8658.8201   -8658.8201    317.59425    317.59425    23649.471    23649.471    2666.0644    2666.0644 
   71000   -8581.6018   -8581.6018   -8660.0725   -8660.0725     303.6897     303.6897    23676.897    23676.897   -1491.2449   -1491.2449 
Loop time of 30.6967 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.815 ns/day, 8.527 hours/ns, 32.577 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.141     | 30.141     | 30.141     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12382    | 0.12382    | 0.12382    |   0.0 |  0.40
Output  | 0.00019583 | 0.00019583 | 0.00019583 |   0.0 |  0.00
Modify  | 0.36665    | 0.36665    | 0.36665    |   0.0 |  1.19
Other   |            | 0.06519    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327736.0 ave      327736 max      327736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327736
Ave neighs/atom = 163.86800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.787047134477, Press = -1.30097462750261
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8581.6018   -8581.6018   -8660.0725   -8660.0725     303.6897     303.6897    23676.897    23676.897   -1491.2449   -1491.2449 
   72000   -8578.9462   -8578.9462   -8659.2181   -8659.2181    310.66054    310.66054    23675.512    23675.512   -662.01345   -662.01345 
Loop time of 30.6747 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.817 ns/day, 8.521 hours/ns, 32.600 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.118     | 30.118     | 30.118     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12391    | 0.12391    | 0.12391    |   0.0 |  0.40
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.36774    | 0.36774    | 0.36774    |   0.0 |  1.20
Other   |            | 0.06521    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5378.00 ave        5378 max        5378 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327088.0 ave      327088 max      327088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327088
Ave neighs/atom = 163.54400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.750686037426, Press = -1.06278151475299
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.9462   -8578.9462   -8659.2181   -8659.2181    310.66054    310.66054    23675.512    23675.512   -662.01345   -662.01345 
   73000   -8580.1766   -8580.1766   -8659.2188   -8659.2188     305.9017     305.9017    23685.363    23685.363   -1300.5758   -1300.5758 
Loop time of 31.0168 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.786 ns/day, 8.616 hours/ns, 32.241 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.453     | 30.453     | 30.453     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12515    | 0.12515    | 0.12515    |   0.0 |  0.40
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.37294    | 0.37294    | 0.37294    |   0.0 |  1.20
Other   |            | 0.06589    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327152.0 ave      327152 max      327152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327152
Ave neighs/atom = 163.57600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.751961092782, Press = -0.385215118607846
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.1766   -8580.1766   -8659.2188   -8659.2188     305.9017     305.9017    23685.363    23685.363   -1300.5758   -1300.5758 
   74000   -8576.6252   -8576.6252   -8658.6671   -8658.6671    317.51068    317.51068    23701.707    23701.707   -2363.1494   -2363.1494 
Loop time of 30.8906 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.797 ns/day, 8.581 hours/ns, 32.372 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.334     | 30.334     | 30.334     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.40
Output  | 0.00045122 | 0.00045122 | 0.00045122 |   0.0 |  0.00
Modify  | 0.36721    | 0.36721    | 0.36721    |   0.0 |  1.19
Other   |            | 0.06597    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5357.00 ave        5357 max        5357 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327136.0 ave      327136 max      327136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327136
Ave neighs/atom = 163.56800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.726484053364, Press = -1.51796843885785
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.6252   -8576.6252   -8658.6671   -8658.6671    317.51068    317.51068    23701.707    23701.707   -2363.1494   -2363.1494 
   75000   -8579.5092   -8579.5092   -8658.8382   -8658.8382    307.01149    307.01149    23664.992    23664.992    1848.2679    1848.2679 
Loop time of 31.0384 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.784 ns/day, 8.622 hours/ns, 32.218 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.479     | 30.479     | 30.479     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12355    | 0.12355    | 0.12355    |   0.0 |  0.40
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.37034    | 0.37034    | 0.37034    |   0.0 |  1.19
Other   |            | 0.06514    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5351.00 ave        5351 max        5351 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326892.0 ave      326892 max      326892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326892
Ave neighs/atom = 163.44600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.731597469917, Press = -1.61899888793421
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.5092   -8579.5092   -8658.8382   -8658.8382    307.01149    307.01149    23664.992    23664.992    1848.2679    1848.2679 
   76000   -8576.2232   -8576.2232   -8657.9753   -8657.9753    316.38891    316.38891    23668.168    23668.168     1898.495     1898.495 
Loop time of 31.1742 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.772 ns/day, 8.659 hours/ns, 32.078 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.609     | 30.609     | 30.609     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12536    | 0.12536    | 0.12536    |   0.0 |  0.40
Output  | 0.00024343 | 0.00024343 | 0.00024343 |   0.0 |  0.00
Modify  | 0.37445    | 0.37445    | 0.37445    |   0.0 |  1.20
Other   |            | 0.06514    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5378.00 ave        5378 max        5378 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327530.0 ave      327530 max      327530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327530
Ave neighs/atom = 163.76500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.737210562797, Press = 0.20871193504566
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.2232   -8576.2232   -8657.9753   -8657.9753    316.38891    316.38891    23668.168    23668.168     1898.495     1898.495 
   77000   -8579.6624   -8579.6624   -8657.3621   -8657.3621    300.70603    300.70603     23698.42     23698.42     -1312.31     -1312.31 
Loop time of 31.5687 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.737 ns/day, 8.769 hours/ns, 31.677 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.994     | 30.994     | 30.994     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12655    | 0.12655    | 0.12655    |   0.0 |  0.40
Output  | 0.00019363 | 0.00019363 | 0.00019363 |   0.0 |  0.00
Modify  | 0.3817     | 0.3817     | 0.3817     |   0.0 |  1.21
Other   |            | 0.06626    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5377.00 ave        5377 max        5377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327438.0 ave      327438 max      327438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327438
Ave neighs/atom = 163.71900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.741004350982, Press = 0.00635447990087782
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.6624   -8579.6624   -8657.3621   -8657.3621    300.70603    300.70603     23698.42     23698.42     -1312.31     -1312.31 
   78000   -8578.9951   -8578.9951   -8657.5275   -8657.5275    303.92838    303.92838    23676.168    23676.168   -437.00468   -437.00468 
Loop time of 31.6157 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.733 ns/day, 8.782 hours/ns, 31.630 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.039     | 31.039     | 31.039     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1271     | 0.1271     | 0.1271     |   0.0 |  0.40
Output  | 0.00015845 | 0.00015845 | 0.00015845 |   0.0 |  0.00
Modify  | 0.38289    | 0.38289    | 0.38289    |   0.0 |  1.21
Other   |            | 0.06614    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326914.0 ave      326914 max      326914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326914
Ave neighs/atom = 163.45700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.701598418188, Press = -1.39028711856898
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.9951   -8578.9951   -8657.5275   -8657.5275    303.92838    303.92838    23676.168    23676.168   -437.00468   -437.00468 
   79000   -8579.5561   -8579.5561   -8661.5524   -8661.5524    317.33402    317.33402    23678.614    23678.614   -544.31995   -544.31995 
Loop time of 31.4423 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.748 ns/day, 8.734 hours/ns, 31.804 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.866     | 30.866     | 30.866     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12853    | 0.12853    | 0.12853    |   0.0 |  0.41
Output  | 0.00015639 | 0.00015639 | 0.00015639 |   0.0 |  0.00
Modify  | 0.38161    | 0.38161    | 0.38161    |   0.0 |  1.21
Other   |            | 0.06554    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5363.00 ave        5363 max        5363 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327518.0 ave      327518 max      327518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327518
Ave neighs/atom = 163.75900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.700448847227, Press = -0.4205847333728
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.5561   -8579.5561   -8661.5524   -8661.5524    317.33402    317.33402    23678.614    23678.614   -544.31995   -544.31995 
   80000    -8575.991    -8575.991   -8657.9317   -8657.9317    317.11902    317.11902    23700.971    23700.971   -2496.6986   -2496.6986 
Loop time of 31.0214 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.785 ns/day, 8.617 hours/ns, 32.236 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.462     | 30.462     | 30.462     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12471    | 0.12471    | 0.12471    |   0.0 |  0.40
Output  | 0.0001973  | 0.0001973  | 0.0001973  |   0.0 |  0.00
Modify  | 0.36886    | 0.36886    | 0.36886    |   0.0 |  1.19
Other   |            | 0.06539    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5382.00 ave        5382 max        5382 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327080.0 ave      327080 max      327080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327080
Ave neighs/atom = 163.54000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.68820189599, Press = -0.429095892641749
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8575.991    -8575.991   -8657.9317   -8657.9317    317.11902    317.11902    23700.971    23700.971   -2496.6986   -2496.6986 
   81000   -8579.3728   -8579.3728   -8661.2321   -8661.2321    316.80391    316.80391     23703.58     23703.58   -2932.0376   -2932.0376 
Loop time of 30.5637 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.827 ns/day, 8.490 hours/ns, 32.719 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.009     | 30.009     | 30.009     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.40
Output  | 0.00015418 | 0.00015418 | 0.00015418 |   0.0 |  0.00
Modify  | 0.36562    | 0.36562    | 0.36562    |   0.0 |  1.20
Other   |            | 0.06609    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5373.00 ave        5373 max        5373 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327018.0 ave      327018 max      327018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327018
Ave neighs/atom = 163.50900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.693426794024, Press = -0.831468431802351
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.3728   -8579.3728   -8661.2321   -8661.2321    316.80391    316.80391     23703.58     23703.58   -2932.0376   -2932.0376 
   82000   -8576.1666   -8576.1666   -8657.8696   -8657.8696    316.19891    316.19891    23649.033    23649.033    3246.5676    3246.5676 
Loop time of 31.605 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.779 hours/ns, 31.641 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.023     | 31.023     | 31.023     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12723    | 0.12723    | 0.12723    |   0.0 |  0.40
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.3881     | 0.3881     | 0.3881     |   0.0 |  1.23
Other   |            | 0.06694    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5362.00 ave        5362 max        5362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326586.0 ave      326586 max      326586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326586
Ave neighs/atom = 163.29300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.729143008445, Press = -1.4041041561728
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.1666   -8576.1666   -8657.8696   -8657.8696    316.19891    316.19891    23649.033    23649.033    3246.5676    3246.5676 
   83000   -8580.5636   -8580.5636   -8661.9441   -8661.9441    314.95072    314.95072     23660.14     23660.14    1111.0022    1111.0022 
Loop time of 31.3265 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.758 ns/day, 8.702 hours/ns, 31.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    | 30.754     | 30.754     | 30.754     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12514    | 0.12514    | 0.12514    |   0.0 |  0.40
Output  | 0.00015708 | 0.00015708 | 0.00015708 |   0.0 |  0.00
Modify  | 0.38088    | 0.38088    | 0.38088    |   0.0 |  1.22
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:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327678.0 ave      327678 max      327678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327678
Ave neighs/atom = 163.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 = 312.762016047674, Press = 0.235275811747934
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.5636   -8580.5636   -8661.9441   -8661.9441    314.95072    314.95072     23660.14     23660.14    1111.0022    1111.0022 
   84000   -8577.9708   -8577.9708   -8658.6115   -8658.6115    312.08761    312.08761    23678.484    23678.484   -854.67106   -854.67106 
Loop time of 31.8222 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.715 ns/day, 8.840 hours/ns, 31.425 timesteps/s
100.0% 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.237     | 31.237     | 31.237     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.129      | 0.129      | 0.129      |   0.0 |  0.41
Output  | 0.00015346 | 0.00015346 | 0.00015346 |   0.0 |  0.00
Modify  | 0.39045    | 0.39045    | 0.39045    |   0.0 |  1.23
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:        5374.00 ave        5374 max        5374 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327300.0 ave      327300 max      327300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327300
Ave neighs/atom = 163.65000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.769406077072, Press = -0.342834858056813
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.9708   -8577.9708   -8658.6115   -8658.6115    312.08761    312.08761    23678.484    23678.484   -854.67106   -854.67106 
   85000   -8579.2051   -8579.2051   -8658.7411   -8658.7411     307.8129     307.8129    23690.987    23690.987   -400.83881   -400.83881 
Loop time of 30.6435 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.820 ns/day, 8.512 hours/ns, 32.633 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.09      | 30.09      | 30.09      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12227    | 0.12227    | 0.12227    |   0.0 |  0.40
Output  | 0.00015211 | 0.00015211 | 0.00015211 |   0.0 |  0.00
Modify  | 0.36566    | 0.36566    | 0.36566    |   0.0 |  1.19
Other   |            | 0.06533    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5374.00 ave        5374 max        5374 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327358.0 ave      327358 max      327358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327358
Ave neighs/atom = 163.67900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.741117990472, Press = -0.917972126343728
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.2051   -8579.2051   -8658.7411   -8658.7411     307.8129     307.8129    23690.987    23690.987   -400.83881   -400.83881 
   86000   -8581.1409   -8581.1409   -8661.4139   -8661.4139    310.66487    310.66487    23639.829    23639.829    2673.7392    2673.7392 
Loop time of 30.6689 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.817 ns/day, 8.519 hours/ns, 32.606 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.111     | 30.111     | 30.111     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12231    | 0.12231    | 0.12231    |   0.0 |  0.40
Output  | 0.00019354 | 0.00019354 | 0.00019354 |   0.0 |  0.00
Modify  | 0.36631    | 0.36631    | 0.36631    |   0.0 |  1.19
Other   |            | 0.06867    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5358.00 ave        5358 max        5358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326816.0 ave      326816 max      326816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326816
Ave neighs/atom = 163.40800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.73799297626, Press = -1.09795985466232
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8581.1409   -8581.1409   -8661.4139   -8661.4139    310.66487    310.66487    23639.829    23639.829    2673.7392    2673.7392 
   87000   -8578.6814   -8578.6814   -8659.7247   -8659.7247    313.64583    313.64583     23652.86     23652.86    2506.1015    2506.1015 
Loop time of 31.4829 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.744 ns/day, 8.745 hours/ns, 31.763 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.91      | 30.91      | 30.91      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12772    | 0.12772    | 0.12772    |   0.0 |  0.41
Output  | 0.00015281 | 0.00015281 | 0.00015281 |   0.0 |  0.00
Modify  | 0.37859    | 0.37859    | 0.37859    |   0.0 |  1.20
Other   |            | 0.06658    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5392.00 ave        5392 max        5392 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327924.0 ave      327924 max      327924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327924
Ave neighs/atom = 163.96200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.728750365444, Press = 0.133647229927998
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.6814   -8578.6814   -8659.7247   -8659.7247    313.64583    313.64583     23652.86     23652.86    2506.1015    2506.1015 
   88000   -8578.3697   -8578.3697   -8658.5708   -8658.5708    310.38641    310.38641    23681.455    23681.455   -478.24294   -478.24294 
Loop time of 30.6441 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.819 ns/day, 8.512 hours/ns, 32.633 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.092     | 30.092     | 30.092     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12276    | 0.12276    | 0.12276    |   0.0 |  0.40
Output  | 0.00015818 | 0.00015818 | 0.00015818 |   0.0 |  0.00
Modify  | 0.3642     | 0.3642     | 0.3642     |   0.0 |  1.19
Other   |            | 0.06503    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5360.00 ave        5360 max        5360 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327598.0 ave      327598 max      327598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327598
Ave neighs/atom = 163.79900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.767376294963, Press = -0.630305489781679
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.3697   -8578.3697   -8658.5708   -8658.5708    310.38641    310.38641    23681.455    23681.455   -478.24294   -478.24294 
   89000   -8579.5284   -8579.5284   -8659.7631   -8659.7631    310.51658    310.51658    23674.476    23674.476   -920.98541   -920.98541 
Loop time of 32.2335 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.680 ns/day, 8.954 hours/ns, 31.024 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.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12935    | 0.12935    | 0.12935    |   0.0 |  0.40
Output  | 0.00020185 | 0.00020185 | 0.00020185 |   0.0 |  0.00
Modify  | 0.39236    | 0.39236    | 0.39236    |   0.0 |  1.22
Other   |            | 0.06638    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327116.0 ave      327116 max      327116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327116
Ave neighs/atom = 163.55800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.778918055242, Press = -0.94690024657335
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.5284   -8579.5284   -8659.7631   -8659.7631    310.51658    310.51658    23674.476    23674.476   -920.98541   -920.98541 
   90000   -8577.2045   -8577.2045   -8658.7494   -8658.7494    315.58718    315.58718    23659.897    23659.897    1595.3195    1595.3195 
Loop time of 31.8752 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.854 hours/ns, 31.372 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.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12751    | 0.12751    | 0.12751    |   0.0 |  0.40
Output  | 0.00015478 | 0.00015478 | 0.00015478 |   0.0 |  0.00
Modify  | 0.38316    | 0.38316    | 0.38316    |   0.0 |  1.20
Other   |            | 0.06648    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5362.00 ave        5362 max        5362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327286.0 ave      327286 max      327286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327286
Ave neighs/atom = 163.64300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.774275682429, Press = -1.31464821661672
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.2045   -8577.2045   -8658.7494   -8658.7494    315.58718    315.58718    23659.897    23659.897    1595.3195    1595.3195 
   91000   -8580.2894   -8580.2894   -8661.4194   -8661.4194    313.98181    313.98181    23650.315    23650.315    2631.9851    2631.9851 
Loop time of 30.9642 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.790 ns/day, 8.601 hours/ns, 32.295 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.4       | 30.4       | 30.4       |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12418    | 0.12418    | 0.12418    |   0.0 |  0.40
Output  | 0.00019302 | 0.00019302 | 0.00019302 |   0.0 |  0.00
Modify  | 0.37346    | 0.37346    | 0.37346    |   0.0 |  1.21
Other   |            | 0.0663     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327404.0 ave      327404 max      327404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327404
Ave neighs/atom = 163.70200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.771872666891, Press = 0.201527565613717
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.2894   -8580.2894   -8661.4194   -8661.4194    313.98181    313.98181    23650.315    23650.315    2631.9851    2631.9851 
   92000    -8578.435    -8578.435   -8658.2834   -8658.2834    309.02182    309.02182    23678.588    23678.588    30.903886    30.903886 
Loop time of 31.2455 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.765 ns/day, 8.679 hours/ns, 32.005 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.674     | 30.674     | 30.674     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12561    | 0.12561    | 0.12561    |   0.0 |  0.40
Output  | 0.00015421 | 0.00015421 | 0.00015421 |   0.0 |  0.00
Modify  | 0.37988    | 0.37988    | 0.37988    |   0.0 |  1.22
Other   |            | 0.06567    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327592.0 ave      327592 max      327592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327592
Ave neighs/atom = 163.79600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.776528406482, Press = -0.652375323982443
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8578.435    -8578.435   -8658.2834   -8658.2834    309.02182    309.02182    23678.588    23678.588    30.903886    30.903886 
   93000   -8578.6453   -8578.6453   -8661.1716   -8661.1716    319.38542    319.38542    23709.152    23709.152   -3480.6497   -3480.6497 
Loop time of 31.6779 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.727 ns/day, 8.799 hours/ns, 31.568 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.098     | 31.098     | 31.098     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12768    | 0.12768    | 0.12768    |   0.0 |  0.40
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.38567    | 0.38567    | 0.38567    |   0.0 |  1.22
Other   |            | 0.06617    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327178.0 ave      327178 max      327178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327178
Ave neighs/atom = 163.58900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.773572969918, Press = -1.0669026161934
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.6453   -8578.6453   -8661.1716   -8661.1716    319.38542    319.38542    23709.152    23709.152   -3480.6497   -3480.6497 
   94000   -8579.0819   -8579.0819   -8661.7713   -8661.7713    320.01652    320.01652    23666.374    23666.374    706.13556    706.13556 
Loop time of 30.4754 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.835 ns/day, 8.465 hours/ns, 32.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    | 29.924     | 29.924     | 29.924     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.40
Output  | 0.00015507 | 0.00015507 | 0.00015507 |   0.0 |  0.00
Modify  | 0.36296    | 0.36296    | 0.36296    |   0.0 |  1.19
Other   |            | 0.06544    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326958.0 ave      326958 max      326958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326958
Ave neighs/atom = 163.47900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.745765128534, Press = -0.73788541642671
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.0819   -8579.0819   -8661.7713   -8661.7713    320.01652    320.01652    23666.374    23666.374    706.13556    706.13556 
   95000    -8577.429    -8577.429   -8658.7535   -8658.7535    314.73422    314.73422     23678.89     23678.89   -605.34603   -605.34603 
Loop time of 30.9869 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.788 ns/day, 8.607 hours/ns, 32.272 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.428     | 30.428     | 30.428     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12464    | 0.12464    | 0.12464    |   0.0 |  0.40
Output  | 0.00017349 | 0.00017349 | 0.00017349 |   0.0 |  0.00
Modify  | 0.36877    | 0.36877    | 0.36877    |   0.0 |  1.19
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:        5370.00 ave        5370 max        5370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327382.0 ave      327382 max      327382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327382
Ave neighs/atom = 163.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 = 312.755246029255, Press = -0.46301436969978
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8577.429    -8577.429   -8658.7535   -8658.7535    314.73422    314.73422     23678.89     23678.89   -605.34603   -605.34603 
   96000   -8579.5669   -8579.5669   -8658.8569   -8658.8569     306.8605     306.8605    23682.857    23682.857    -880.1059    -880.1059 
Loop time of 31.3405 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.757 ns/day, 8.706 hours/ns, 31.908 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.767     | 30.767     | 30.767     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12588    | 0.12588    | 0.12588    |   0.0 |  0.40
Output  | 0.00020511 | 0.00020511 | 0.00020511 |   0.0 |  0.00
Modify  | 0.38197    | 0.38197    | 0.38197    |   0.0 |  1.22
Other   |            | 0.06518    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5361.00 ave        5361 max        5361 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327156.0 ave      327156 max      327156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327156
Ave neighs/atom = 163.57800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.758061816305, Press = -1.46151212035445
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.5669   -8579.5669   -8658.8569   -8658.8569     306.8605     306.8605    23682.857    23682.857    -880.1059    -880.1059 
   97000   -8578.4387   -8578.4387   -8659.2153   -8659.2153    312.61399    312.61399    23676.544    23676.544    890.29628    890.29628 
Loop time of 32.1101 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.691 ns/day, 8.919 hours/ns, 31.143 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.527     | 31.527     | 31.527     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12899    | 0.12899    | 0.12899    |   0.0 |  0.40
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.38818    | 0.38818    | 0.38818    |   0.0 |  1.21
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:        5381.00 ave        5381 max        5381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327122.0 ave      327122 max      327122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327122
Ave neighs/atom = 163.56100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.747798413425, Press = -1.35689809474056
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.4387   -8578.4387   -8659.2153   -8659.2153    312.61399    312.61399    23676.544    23676.544    890.29628    890.29628 
   98000   -8580.3019   -8580.3019    -8661.379    -8661.379    313.77692    313.77692     23664.94     23664.94    618.63402    618.63402 
Loop time of 30.9452 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.792 ns/day, 8.596 hours/ns, 32.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    | 30.387     | 30.387     | 30.387     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12329    | 0.12329    | 0.12329    |   0.0 |  0.40
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.36952    | 0.36952    | 0.36952    |   0.0 |  1.19
Other   |            | 0.06527    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5381.00 ave        5381 max        5381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327408.0 ave      327408 max      327408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327408
Ave neighs/atom = 163.70400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.725574875368, Press = 0.00570206075663551
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.3019   -8580.3019    -8661.379    -8661.379    313.77692    313.77692     23664.94     23664.94    618.63402    618.63402 
   99000   -8575.6371   -8575.6371   -8658.1651   -8658.1651    319.39182    319.39182    23695.955    23695.955   -859.12969   -859.12969 
Loop time of 30.6658 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.817 ns/day, 8.518 hours/ns, 32.610 timesteps/s
100.0% 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.111     | 30.111     | 30.111     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.40
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.36675    | 0.36675    | 0.36675    |   0.0 |  1.20
Other   |            | 0.06454    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5379.00 ave        5379 max        5379 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327480.0 ave      327480 max      327480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327480
Ave neighs/atom = 163.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 = 312.750789451472, Press = -0.835600427661127
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8575.6371   -8575.6371   -8658.1651   -8658.1651    319.39182    319.39182    23695.955    23695.955   -859.12969   -859.12969 
  100000   -8581.3346   -8581.3346   -8660.7524   -8660.7524    307.35512    307.35512    23651.229    23651.229    3311.9512    3311.9512 
Loop time of 31.6111 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.733 ns/day, 8.781 hours/ns, 31.634 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.031     | 31.031     | 31.031     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1281     | 0.1281     | 0.1281     |   0.0 |  0.41
Output  | 0.00015429 | 0.00015429 | 0.00015429 |   0.0 |  0.00
Modify  | 0.3855     | 0.3855     | 0.3855     |   0.0 |  1.22
Other   |            | 0.06586    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327048.0 ave      327048 max      327048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327048
Ave neighs/atom = 163.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 = 312.764372959281, Press = -0.314682072680858
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8581.3346   -8581.3346   -8660.7524   -8660.7524    307.35512    307.35512    23651.229    23651.229    3311.9512    3311.9512 
  101000   -8577.6975   -8577.6975   -8658.9199   -8658.9199    314.33923    314.33923     23693.23     23693.23   -2622.8101   -2622.8101 
Loop time of 31.8427 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.713 ns/day, 8.845 hours/ns, 31.404 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.251     | 31.251     | 31.251     |   0.0 | 98.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13034    | 0.13034    | 0.13034    |   0.0 |  0.41
Output  | 0.00019513 | 0.00019513 | 0.00019513 |   0.0 |  0.00
Modify  | 0.39465    | 0.39465    | 0.39465    |   0.0 |  1.24
Other   |            | 0.06683    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5374.00 ave        5374 max        5374 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327544.0 ave      327544 max      327544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327544
Ave neighs/atom = 163.77200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.758223753831, Press = -0.339382464599014
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.6975   -8577.6975   -8658.9199   -8658.9199    314.33923    314.33923     23693.23     23693.23   -2622.8101   -2622.8101 
  102000   -8581.0841   -8581.0841   -8659.8113   -8659.8113    304.68226    304.68226    23693.916    23693.916   -992.81948   -992.81948 
Loop time of 30.9634 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.790 ns/day, 8.601 hours/ns, 32.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    | 30.402     | 30.402     | 30.402     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12403    | 0.12403    | 0.12403    |   0.0 |  0.40
Output  | 0.00015434 | 0.00015434 | 0.00015434 |   0.0 |  0.00
Modify  | 0.37211    | 0.37211    | 0.37211    |   0.0 |  1.20
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:        5364.00 ave        5364 max        5364 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327198.0 ave      327198 max      327198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327198
Ave neighs/atom = 163.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 = 312.735429945959, Press = -1.37349295852726
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8581.0841   -8581.0841   -8659.8113   -8659.8113    304.68226    304.68226    23693.916    23693.916   -992.81948   -992.81948 
  103000   -8577.3512   -8577.3512   -8659.8005   -8659.8005    319.08726    319.08726    23679.629    23679.629   -932.48524   -932.48524 
Loop time of 30.756 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.809 ns/day, 8.543 hours/ns, 32.514 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.198     | 30.198     | 30.198     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12342    | 0.12342    | 0.12342    |   0.0 |  0.40
Output  | 0.00015355 | 0.00015355 | 0.00015355 |   0.0 |  0.00
Modify  | 0.36849    | 0.36849    | 0.36849    |   0.0 |  1.20
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:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327042.0 ave      327042 max      327042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327042
Ave neighs/atom = 163.52100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.722546702496, Press = -0.449917395113059
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.3512   -8577.3512   -8659.8005   -8659.8005    319.08726    319.08726    23679.629    23679.629   -932.48524   -932.48524 
  104000   -8579.2557   -8579.2557   -8660.0198   -8660.0198    312.56554    312.56554    23705.971    23705.971   -3069.4372   -3069.4372 
Loop time of 31.5193 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.741 ns/day, 8.755 hours/ns, 31.727 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.948     | 30.948     | 30.948     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12703    | 0.12703    | 0.12703    |   0.0 |  0.40
Output  | 0.00015156 | 0.00015156 | 0.00015156 |   0.0 |  0.00
Modify  | 0.37772    | 0.37772    | 0.37772    |   0.0 |  1.20
Other   |            | 0.06612    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327260.0 ave      327260 max      327260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327260
Ave neighs/atom = 163.63000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.749890955248, Press = -1.35574008917678
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.2557   -8579.2557   -8660.0198   -8660.0198    312.56554    312.56554    23705.971    23705.971   -3069.4372   -3069.4372 
  105000   -8573.5918   -8573.5918   -8657.6857   -8657.6857    325.45236    325.45236    23668.988    23668.988    1585.3221    1585.3221 
Loop time of 31.6291 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.732 ns/day, 8.786 hours/ns, 31.616 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.053     | 31.053     | 31.053     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12687    | 0.12687    | 0.12687    |   0.0 |  0.40
Output  | 0.00015075 | 0.00015075 | 0.00015075 |   0.0 |  0.00
Modify  | 0.38338    | 0.38338    | 0.38338    |   0.0 |  1.21
Other   |            | 0.06568    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5363.00 ave        5363 max        5363 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326812.0 ave      326812 max      326812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326812
Ave neighs/atom = 163.40600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.776829123852, Press = -1.2388079900057
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8573.5918   -8573.5918   -8657.6857   -8657.6857    325.45236    325.45236    23668.988    23668.988    1585.3221    1585.3221 
  106000   -8580.4787   -8580.4787   -8659.7698   -8659.7698    306.86474    306.86474    23663.547    23663.547    1286.8807    1286.8807 
Loop time of 31.7606 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.720 ns/day, 8.822 hours/ns, 31.486 timesteps/s
100.0% 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.181     | 31.181     | 31.181     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12817    | 0.12817    | 0.12817    |   0.0 |  0.40
Output  | 0.00015173 | 0.00015173 | 0.00015173 |   0.0 |  0.00
Modify  | 0.38478    | 0.38478    | 0.38478    |   0.0 |  1.21
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:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327216.0 ave      327216 max      327216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327216
Ave neighs/atom = 163.60800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.791607623643, Press = -0.72864049228873
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.4787   -8580.4787   -8659.7698   -8659.7698    306.86474    306.86474    23663.547    23663.547    1286.8807    1286.8807 
  107000   -8579.1126   -8579.1126   -8658.8496   -8658.8496    308.59049    308.59049    23671.824    23671.824     1181.392     1181.392 
Loop time of 31.0373 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.784 ns/day, 8.621 hours/ns, 32.219 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.471     | 30.471     | 30.471     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12444    | 0.12444    | 0.12444    |   0.0 |  0.40
Output  | 0.00015405 | 0.00015405 | 0.00015405 |   0.0 |  0.00
Modify  | 0.37552    | 0.37552    | 0.37552    |   0.0 |  1.21
Other   |            | 0.06571    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5371.00 ave        5371 max        5371 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327542.0 ave      327542 max      327542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327542
Ave neighs/atom = 163.77100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.815387333264, Press = -0.128040252189521
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.1126   -8579.1126   -8658.8496   -8658.8496    308.59049    308.59049    23671.824    23671.824     1181.392     1181.392 
  108000   -8577.1813   -8577.1813   -8659.0274   -8659.0274    316.75293    316.75293    23734.183    23734.183   -6099.2504   -6099.2504 
Loop time of 30.871 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.799 ns/day, 8.575 hours/ns, 32.393 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.313     | 30.313     | 30.313     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12381    | 0.12381    | 0.12381    |   0.0 |  0.40
Output  | 0.00015574 | 0.00015574 | 0.00015574 |   0.0 |  0.00
Modify  | 0.3683     | 0.3683     | 0.3683     |   0.0 |  1.19
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:        5369.00 ave        5369 max        5369 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327720.0 ave      327720 max      327720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327720
Ave neighs/atom = 163.86000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.833665312326, Press = -0.726141062600851
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.1813   -8577.1813   -8659.0274   -8659.0274    316.75293    316.75293    23734.183    23734.183   -6099.2504   -6099.2504 
  109000   -8580.2774   -8580.2774   -8660.2027   -8660.2027    309.31902    309.31902     23686.53     23686.53   -1693.2712   -1693.2712 
Loop time of 31.3368 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.757 ns/day, 8.705 hours/ns, 31.911 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.763     | 30.763     | 30.763     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12648    | 0.12648    | 0.12648    |   0.0 |  0.40
Output  | 0.0001571  | 0.0001571  | 0.0001571  |   0.0 |  0.00
Modify  | 0.38073    | 0.38073    | 0.38073    |   0.0 |  1.21
Other   |            | 0.06658    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326336.0 ave      326336 max      326336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326336
Ave neighs/atom = 163.16800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.860881705015, Press = -1.1263941201203
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.2774   -8580.2774   -8660.2027   -8660.2027    309.31902    309.31902     23686.53     23686.53   -1693.2712   -1693.2712 
  110000    -8578.478    -8578.478   -8657.9305   -8657.9305    307.48953    307.48953    23666.986    23666.986    1660.5795    1660.5795 
Loop time of 30.7111 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.813 ns/day, 8.531 hours/ns, 32.562 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.15      | 30.15      | 30.15      |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12437    | 0.12437    | 0.12437    |   0.0 |  0.40
Output  | 0.00015215 | 0.00015215 | 0.00015215 |   0.0 |  0.00
Modify  | 0.37136    | 0.37136    | 0.37136    |   0.0 |  1.21
Other   |            | 0.06538    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5382.00 ave        5382 max        5382 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326894.0 ave      326894 max      326894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326894
Ave neighs/atom = 163.44700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.885072386286, Press = -1.06574242892943
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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    -8578.478    -8578.478   -8657.9305   -8657.9305    307.48953    307.48953    23666.986    23666.986    1660.5795    1660.5795 
  111000   -8575.0922   -8575.0922   -8655.7962   -8655.7962    312.33278    312.33278    23694.619    23694.619   -566.81139   -566.81139 
Loop time of 31.304 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.760 ns/day, 8.696 hours/ns, 31.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.734     | 30.734     | 30.734     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12571    | 0.12571    | 0.12571    |   0.0 |  0.40
Output  | 0.00015428 | 0.00015428 | 0.00015428 |   0.0 |  0.00
Modify  | 0.37788    | 0.37788    | 0.37788    |   0.0 |  1.21
Other   |            | 0.06589    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5370.00 ave        5370 max        5370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327500.0 ave      327500 max      327500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327500
Ave neighs/atom = 163.75000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.887642591304, Press = -0.560312793007343
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8575.0922   -8575.0922   -8655.7962   -8655.7962    312.33278    312.33278    23694.619    23694.619   -566.81139   -566.81139 
  112000   -8579.6775   -8579.6775    -8659.034    -8659.034    307.11782    307.11782    23680.223    23680.223      57.2051      57.2051 
Loop time of 31.146 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.774 ns/day, 8.652 hours/ns, 32.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    | 30.579     | 30.579     | 30.579     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12574    | 0.12574    | 0.12574    |   0.0 |  0.40
Output  | 0.00015158 | 0.00015158 | 0.00015158 |   0.0 |  0.00
Modify  | 0.37545    | 0.37545    | 0.37545    |   0.0 |  1.21
Other   |            | 0.06532    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5366.00 ave        5366 max        5366 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327270.0 ave      327270 max      327270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327270
Ave neighs/atom = 163.63500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.904921999426, Press = -0.775373836351163
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.6775   -8579.6775    -8659.034    -8659.034    307.11782    307.11782    23680.223    23680.223      57.2051      57.2051 
  113000   -8578.3501   -8578.3501   -8659.2256   -8659.2256    312.99668    312.99668    23663.643    23663.643    1829.2861    1829.2861 
Loop time of 31.5745 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.736 ns/day, 8.771 hours/ns, 31.671 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.004     | 31.004     | 31.004     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12603    | 0.12603    | 0.12603    |   0.0 |  0.40
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.37871    | 0.37871    | 0.37871    |   0.0 |  1.20
Other   |            | 0.06607    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5384.00 ave        5384 max        5384 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327166.0 ave      327166 max      327166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327166
Ave neighs/atom = 163.58300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.902730918587, Press = -0.720920836851231
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.3501   -8578.3501   -8659.2256   -8659.2256    312.99668    312.99668    23663.643    23663.643    1829.2861    1829.2861 
  114000   -8581.3832   -8581.3832   -8662.4202   -8662.4202    313.62154    313.62154    23662.441    23662.441    708.69776    708.69776 
Loop time of 31.0149 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.786 ns/day, 8.615 hours/ns, 32.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    | 30.455     | 30.455     | 30.455     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12394    | 0.12394    | 0.12394    |   0.0 |  0.40
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.37086    | 0.37086    | 0.37086    |   0.0 |  1.20
Other   |            | 0.06522    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5382.00 ave        5382 max        5382 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327428.0 ave      327428 max      327428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327428
Ave neighs/atom = 163.71400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.899358119834, Press = -0.269495474946285
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8581.3832   -8581.3832   -8662.4202   -8662.4202    313.62154    313.62154    23662.441    23662.441    708.69776    708.69776 
  115000   -8577.2591   -8577.2591   -8660.4665   -8660.4665    322.02122    322.02122    23683.733    23683.733   -1502.0837   -1502.0837 
Loop time of 31.0694 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.781 ns/day, 8.630 hours/ns, 32.186 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.504     | 30.504     | 30.504     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12536    | 0.12536    | 0.12536    |   0.0 |  0.40
Output  | 0.00019482 | 0.00019482 | 0.00019482 |   0.0 |  0.00
Modify  | 0.37473    | 0.37473    | 0.37473    |   0.0 |  1.21
Other   |            | 0.06534    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5384.00 ave        5384 max        5384 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327344.0 ave      327344 max      327344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327344
Ave neighs/atom = 163.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 = 312.893498124178, Press = -0.874423826521392
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8577.2591   -8577.2591   -8660.4665   -8660.4665    322.02122    322.02122    23683.733    23683.733   -1502.0837   -1502.0837 
  116000   -8580.8314   -8580.8314     -8662.25     -8662.25    315.09851    315.09851    23655.517    23655.517    884.18499    884.18499 
Loop time of 30.8716 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.799 ns/day, 8.575 hours/ns, 32.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    | 30.312     | 30.312     | 30.312     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12365    | 0.12365    | 0.12365    |   0.0 |  0.40
Output  | 0.00019915 | 0.00019915 | 0.00019915 |   0.0 |  0.00
Modify  | 0.37043    | 0.37043    | 0.37043    |   0.0 |  1.20
Other   |            | 0.06494    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5377.00 ave        5377 max        5377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327302.0 ave      327302 max      327302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327302
Ave neighs/atom = 163.65100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.871164213544, Press = -0.623019079602941
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.8314   -8580.8314     -8662.25     -8662.25    315.09851    315.09851    23655.517    23655.517    884.18499    884.18499 
  117000   -8580.8974   -8580.8974   -8660.8396   -8660.8396    309.38459    309.38459    23652.821    23652.821    1689.5617    1689.5617 
Loop time of 31.3341 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.757 ns/day, 8.704 hours/ns, 31.914 timesteps/s
100.0% 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.769     | 30.769     | 30.769     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12553    | 0.12553    | 0.12553    |   0.0 |  0.40
Output  | 0.00015214 | 0.00015214 | 0.00015214 |   0.0 |  0.00
Modify  | 0.37479    | 0.37479    | 0.37479    |   0.0 |  1.20
Other   |            | 0.06485    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5357.00 ave        5357 max        5357 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327484.0 ave      327484 max      327484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327484
Ave neighs/atom = 163.74200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.865093696744, Press = -0.237139271435569
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.8974   -8580.8974   -8660.8396   -8660.8396    309.38459    309.38459    23652.821    23652.821    1689.5617    1689.5617 
  118000   -8576.3186   -8576.3186   -8657.1305   -8657.1305    312.75061    312.75061    23690.798    23690.798   -621.27329   -621.27329 
Loop time of 30.8212 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.803 ns/day, 8.561 hours/ns, 32.445 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.265     | 30.265     | 30.265     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12321    | 0.12321    | 0.12321    |   0.0 |  0.40
Output  | 0.00015621 | 0.00015621 | 0.00015621 |   0.0 |  0.00
Modify  | 0.36773    | 0.36773    | 0.36773    |   0.0 |  1.19
Other   |            | 0.06521    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5362.00 ave        5362 max        5362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327764.0 ave      327764 max      327764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327764
Ave neighs/atom = 163.88200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.875959155785, Press = -1.15284689984853
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8576.3186   -8576.3186   -8657.1305   -8657.1305    312.75061    312.75061    23690.798    23690.798   -621.27329   -621.27329 
  119000   -8579.8561   -8579.8561   -8660.6668   -8660.6668    312.74577    312.74577    23654.411    23654.411    3032.0638    3032.0638 
Loop time of 31.8911 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.709 ns/day, 8.859 hours/ns, 31.357 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.31      | 31.31      | 31.31      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12822    | 0.12822    | 0.12822    |   0.0 |  0.40
Output  | 0.00025362 | 0.00025362 | 0.00025362 |   0.0 |  0.00
Modify  | 0.38687    | 0.38687    | 0.38687    |   0.0 |  1.21
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:        5367.00 ave        5367 max        5367 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327092.0 ave      327092 max      327092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327092
Ave neighs/atom = 163.54600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.89013727372, Press = -0.402129899444583
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.8561   -8579.8561   -8660.6668   -8660.6668    312.74577    312.74577    23654.411    23654.411    3032.0638    3032.0638 
  120000   -8578.5489   -8578.5489     -8661.19     -8661.19     319.8296     319.8296    23674.033    23674.033   -958.45193   -958.45193 
Loop time of 31.7358 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.722 ns/day, 8.815 hours/ns, 31.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    | 31.159     | 31.159     | 31.159     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12722    | 0.12722    | 0.12722    |   0.0 |  0.40
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.38339    | 0.38339    | 0.38339    |   0.0 |  1.21
Other   |            | 0.06583    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327538.0 ave      327538 max      327538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327538
Ave neighs/atom = 163.76900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.909921224339, Press = -0.0772756629720602
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.5489   -8578.5489     -8661.19     -8661.19     319.8296     319.8296    23674.033    23674.033   -958.45193   -958.45193 
  121000   -8578.5917   -8578.5917   -8659.0195   -8659.0195     311.2637     311.2637    23706.224    23706.224   -2039.8754   -2039.8754 
Loop time of 31.363 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.755 ns/day, 8.712 hours/ns, 31.885 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.79      | 30.79      | 30.79      |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12663    | 0.12663    | 0.12663    |   0.0 |  0.40
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.37944    | 0.37944    | 0.37944    |   0.0 |  1.21
Other   |            | 0.06669    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327368.0 ave      327368 max      327368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327368
Ave neighs/atom = 163.68400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.907418804869, Press = -0.888372747541361
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.5917   -8578.5917   -8659.0195   -8659.0195     311.2637     311.2637    23706.224    23706.224   -2039.8754   -2039.8754 
  122000   -8580.8222   -8580.8222   -8660.7313   -8660.7313    309.25621    309.25621    23654.724    23654.724    625.50107    625.50107 
Loop time of 31.5097 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.742 ns/day, 8.753 hours/ns, 31.736 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.935     | 30.935     | 30.935     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12672    | 0.12672    | 0.12672    |   0.0 |  0.40
Output  | 0.00015605 | 0.00015605 | 0.00015605 |   0.0 |  0.00
Modify  | 0.38125    | 0.38125    | 0.38125    |   0.0 |  1.21
Other   |            | 0.06614    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326652.0 ave      326652 max      326652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326652
Ave neighs/atom = 163.32600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.908431887052, Press = -0.818797045483852
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.8222   -8580.8222   -8660.7313   -8660.7313    309.25621    309.25621    23654.724    23654.724    625.50107    625.50107 
  123000   -8579.1899   -8579.1899   -8661.3703   -8661.3703    318.04675    318.04675    23664.089    23664.089    1443.1788    1443.1788 
Loop time of 31.4798 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.744 hours/ns, 31.766 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.906     | 30.906     | 30.906     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12658    | 0.12658    | 0.12658    |   0.0 |  0.40
Output  | 0.00015399 | 0.00015399 | 0.00015399 |   0.0 |  0.00
Modify  | 0.38188    | 0.38188    | 0.38188    |   0.0 |  1.21
Other   |            | 0.06557    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5364.00 ave        5364 max        5364 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327666.0 ave      327666 max      327666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327666
Ave neighs/atom = 163.83300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.926376516354, Press = -0.989759128744562
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8579.1899   -8579.1899   -8661.3703   -8661.3703    318.04675    318.04675    23664.089    23664.089    1443.1788    1443.1788 
  124000   -8574.4232   -8574.4232    -8657.207    -8657.207    320.38219    320.38219    23660.425    23660.425    2061.6994    2061.6994 
Loop time of 31.2984 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.761 ns/day, 8.694 hours/ns, 31.950 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.73      | 30.73      | 30.73      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12685    | 0.12685    | 0.12685    |   0.0 |  0.41
Output  | 0.00015853 | 0.00015853 | 0.00015853 |   0.0 |  0.00
Modify  | 0.37521    | 0.37521    | 0.37521    |   0.0 |  1.20
Other   |            | 0.06588    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327298.0 ave      327298 max      327298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327298
Ave neighs/atom = 163.64900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.944994188943, Press = 0.506753902951558
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8574.4232   -8574.4232    -8657.207    -8657.207    320.38219    320.38219    23660.425    23660.425    2061.6994    2061.6994 
  125000   -8580.4509   -8580.4509   -8659.4516   -8659.4516    305.74073    305.74073     23669.82     23669.82     203.3883     203.3883 
Loop time of 31.5973 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.777 hours/ns, 31.648 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.015     | 31.015     | 31.015     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12746    | 0.12746    | 0.12746    |   0.0 |  0.40
Output  | 0.00015623 | 0.00015623 | 0.00015623 |   0.0 |  0.00
Modify  | 0.38812    | 0.38812    | 0.38812    |   0.0 |  1.23
Other   |            | 0.0664     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5363.00 ave        5363 max        5363 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327488.0 ave      327488 max      327488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327488
Ave neighs/atom = 163.74400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.961007539962, Press = -0.731840125006146
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8580.4509   -8580.4509   -8659.4516   -8659.4516    305.74073    305.74073     23669.82     23669.82     203.3883     203.3883 
  126000   -8578.2804   -8578.2804   -8659.4623   -8659.4623    314.18219    314.18219    23679.567    23679.567   -29.739634   -29.739634 
Loop time of 30.7697 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.808 ns/day, 8.547 hours/ns, 32.500 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.212     | 30.212     | 30.212     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12415    | 0.12415    | 0.12415    |   0.0 |  0.40
Output  | 0.00020086 | 0.00020086 | 0.00020086 |   0.0 |  0.00
Modify  | 0.36783    | 0.36783    | 0.36783    |   0.0 |  1.20
Other   |            | 0.0654     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5372.00 ave        5372 max        5372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327472.0 ave      327472 max      327472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327472
Ave neighs/atom = 163.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.968789230463, Press = -0.737089363950457
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8578.2804   -8578.2804   -8659.4623   -8659.4623    314.18219    314.18219    23679.567    23679.567   -29.739634   -29.739634 
  127000   -8575.9789   -8575.9789   -8658.5068   -8658.5068    319.39149    319.39149    23674.818    23674.818    390.13722    390.13722 
Loop time of 30.916 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.795 ns/day, 8.588 hours/ns, 32.346 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.357     | 30.357     | 30.357     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12442    | 0.12442    | 0.12442    |   0.0 |  0.40
Output  | 0.00015373 | 0.00015373 | 0.00015373 |   0.0 |  0.00
Modify  | 0.36951    | 0.36951    | 0.36951    |   0.0 |  1.20
Other   |            | 0.0648     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5370.00 ave        5370 max        5370 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327124.0 ave      327124 max      327124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327124
Ave neighs/atom = 163.56200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.96907077872, Press = -0.560857415483917
next a
jump SELF top
variable a loop 2000
run 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.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      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   -8575.9789   -8575.9789   -8658.5068   -8658.5068    319.39149    319.39149    23674.818    23674.818    390.13722    390.13722 
  128000   -8576.5335   -8576.5335   -8658.0932   -8658.0932    315.64461    315.64461    23672.953    23672.953    542.08251    542.08251 
Loop time of 30.8482 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.801 ns/day, 8.569 hours/ns, 32.417 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.292     | 30.292     | 30.292     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12337    | 0.12337    | 0.12337    |   0.0 |  0.40
Output  | 0.00015506 | 0.00015506 | 0.00015506 |   0.0 |  0.00
Modify  | 0.36758    | 0.36758    | 0.36758    |   0.0 |  1.19
Other   |            | 0.06529    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327392.0 ave      327392 max      327392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327392
Ave neighs/atom = 163.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"
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
23669.0869987513

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0