# 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.85487599670887*${_u_distance}
variable latticeconst_converted equal 2.85487599670887*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85487599670887
Lattice spacing in x,y,z = 2.8548760 2.8548760 2.8548760
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.548760 28.548760 28.548760)
  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.548760 28.548760 28.548760)
  create_atoms CPU = 0.001 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_Wen_2021_FeH__MO_634187028437_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 23268.1442449223    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23268.1442449223/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23268.1442449223/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23268.1442449223/(1*1*${_u_distance})
variable      V0_metal equal 23268.1442449223/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23268.1442449223*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23268.1442449223 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_634187028437_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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -7955.0492   -7955.0492   -8030.7966   -8030.7966       293.15       293.15    23268.144    23268.144    3477.1266    3477.1266 
    1000   -7875.6772   -7875.6772   -7944.8771   -7944.8771    267.81063    267.81063    23377.651    23377.651    425.68125    425.68125 
Loop time of 11.7887 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.329 ns/day, 3.275 hours/ns, 84.827 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.566     | 11.566     | 11.566     |   0.0 | 98.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044233   | 0.044233   | 0.044233   |   0.0 |  0.38
Output  | 0.00027224 | 0.00027224 | 0.00027224 |   0.0 |  0.00
Modify  | 0.15258    | 0.15258    | 0.15258    |   0.0 |  1.29
Other   |            | 0.02588    |            |       |  0.22

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

Total # of neighbors = 272000
Ave neighs/atom = 136.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7875.6772   -7875.6772   -7944.8771   -7944.8771    267.81063    267.81063    23377.651    23377.651    425.68125    425.68125 
    2000   -7875.1809   -7875.1809   -7951.8122   -7951.8122    296.57104    296.57104     23384.39     23384.39   -724.66795   -724.66795 
Loop time of 11.9768 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.214 ns/day, 3.327 hours/ns, 83.494 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.763     | 11.763     | 11.763     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042875   | 0.042875   | 0.042875   |   0.0 |  0.36
Output  | 0.00011519 | 0.00011519 | 0.00011519 |   0.0 |  0.00
Modify  | 0.1471     | 0.1471     | 0.1471     |   0.0 |  1.23
Other   |            | 0.02366    |            |       |  0.20

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

Total # of neighbors = 278270
Ave neighs/atom = 139.13500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -7875.1809   -7875.1809   -7951.8122   -7951.8122    296.57104    296.57104     23384.39     23384.39   -724.66795   -724.66795 
    3000   -7876.3451   -7876.3451   -7948.5412   -7948.5412    279.40651    279.40651    23344.947    23344.947     2269.775     2269.775 
Loop time of 11.945 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.233 ns/day, 3.318 hours/ns, 83.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.735     | 11.735     | 11.735     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042155   | 0.042155   | 0.042155   |   0.0 |  0.35
Output  | 0.00012988 | 0.00012988 | 0.00012988 |   0.0 |  0.00
Modify  | 0.14443    | 0.14443    | 0.14443    |   0.0 |  1.21
Other   |            | 0.02327    |            |       |  0.19

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

Total # of neighbors = 277158
Ave neighs/atom = 138.57900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -7876.3451   -7876.3451   -7948.5412   -7948.5412    279.40651    279.40651    23344.947    23344.947     2269.775     2269.775 
    4000   -7874.5282   -7874.5282   -7950.9996   -7950.9996    295.95201    295.95201    23345.856    23345.856     2580.891     2580.891 
Loop time of 12.3874 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.975 ns/day, 3.441 hours/ns, 80.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    | 12.164     | 12.164     | 12.164     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04394    | 0.04394    | 0.04394    |   0.0 |  0.35
Output  | 0.00010376 | 0.00010376 | 0.00010376 |   0.0 |  0.00
Modify  | 0.15461    | 0.15461    | 0.15461    |   0.0 |  1.25
Other   |            | 0.02449    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5465.00 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277868.0 ave      277868 max      277868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277868
Ave neighs/atom = 138.93400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -7874.5282   -7874.5282   -7950.9996   -7950.9996    295.95201    295.95201    23345.856    23345.856     2580.891     2580.891 
    5000    -7876.773    -7876.773   -7952.9403   -7952.9403    294.77505    294.77505    23372.018    23372.018    912.52576    912.52576 
Loop time of 12.0472 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.172 ns/day, 3.346 hours/ns, 83.007 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.835     | 11.835     | 11.835     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04266    | 0.04266    | 0.04266    |   0.0 |  0.35
Output  | 8.7759e-05 | 8.7759e-05 | 8.7759e-05 |   0.0 |  0.00
Modify  | 0.14671    | 0.14671    | 0.14671    |   0.0 |  1.22
Other   |            | 0.02304    |            |       |  0.19

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

Total # of neighbors = 277612
Ave neighs/atom = 138.80600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.197188166896, Press = -133.545159949943
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -7876.773    -7876.773   -7952.9403   -7952.9403    294.77505    294.77505    23372.018    23372.018    912.52576    912.52576 
    6000    -7874.158    -7874.158   -7947.6511   -7947.6511    284.42579    284.42579     23364.11     23364.11    1168.2568    1168.2568 
Loop time of 11.9843 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.209 ns/day, 3.329 hours/ns, 83.442 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.77      | 11.77      | 11.77      |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042238   | 0.042238   | 0.042238   |   0.0 |  0.35
Output  | 9.0823e-05 | 9.0823e-05 | 9.0823e-05 |   0.0 |  0.00
Modify  | 0.14919    | 0.14919    | 0.14919    |   0.0 |  1.24
Other   |            | 0.02255    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5463.00 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276826.0 ave      276826 max      276826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276826
Ave neighs/atom = 138.41300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.629387223302, Press = -34.926828932592
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    -7874.158    -7874.158   -7947.6511   -7947.6511    284.42579    284.42579     23364.11     23364.11    1168.2568    1168.2568 
    7000   -7876.3716   -7876.3716   -7952.6052   -7952.6052    295.03189    295.03189    23361.644    23361.644    1799.4749    1799.4749 
Loop time of 12.1872 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.089 ns/day, 3.385 hours/ns, 82.053 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.966     | 11.966     | 11.966     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043162   | 0.043162   | 0.043162   |   0.0 |  0.35
Output  | 6.5252e-05 | 6.5252e-05 | 6.5252e-05 |   0.0 |  0.00
Modify  | 0.15479    | 0.15479    | 0.15479    |   0.0 |  1.27
Other   |            | 0.02326    |            |       |  0.19

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

Total # of neighbors = 277990
Ave neighs/atom = 138.99500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.941182369773, Press = -33.3094034631408
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -7876.3716   -7876.3716   -7952.6052   -7952.6052    295.03189    295.03189    23361.644    23361.644    1799.4749    1799.4749 
    8000    -7875.143    -7875.143   -7950.3191   -7950.3191    290.93931    290.93931    23366.026    23366.026    922.09477    922.09477 
Loop time of 12.4064 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.964 ns/day, 3.446 hours/ns, 80.604 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.174     | 12.174     | 12.174     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044964   | 0.044964   | 0.044964   |   0.0 |  0.36
Output  | 0.00010393 | 0.00010393 | 0.00010393 |   0.0 |  0.00
Modify  | 0.16225    | 0.16225    | 0.16225    |   0.0 |  1.31
Other   |            | 0.02529    |            |       |  0.20

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

Total # of neighbors = 277036
Ave neighs/atom = 138.51800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.041799930147, Press = -38.9660658538717
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -7875.143    -7875.143   -7950.3191   -7950.3191    290.93931    290.93931    23366.026    23366.026    922.09477    922.09477 
    9000   -7877.8553   -7877.8553   -7953.1149   -7953.1149    291.26242    291.26242    23381.185    23381.185    529.49171    529.49171 
Loop time of 12.1653 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.102 ns/day, 3.379 hours/ns, 82.201 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.942     | 11.942     | 11.942     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043324   | 0.043324   | 0.043324   |   0.0 |  0.36
Output  | 9.8064e-05 | 9.8064e-05 | 9.8064e-05 |   0.0 |  0.00
Modify  | 0.15559    | 0.15559    | 0.15559    |   0.0 |  1.28
Other   |            | 0.02401    |            |       |  0.20

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

Total # of neighbors = 277488
Ave neighs/atom = 138.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 = 292.885825038591, Press = -19.1136576502572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -7877.8553   -7877.8553   -7953.1149   -7953.1149    291.26242    291.26242    23381.185    23381.185    529.49171    529.49171 
   10000    -7874.256    -7874.256   -7950.1303   -7950.1303    293.64138    293.64138    23397.512    23397.512   -743.75615   -743.75615 
Loop time of 12.3234 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.011 ns/day, 3.423 hours/ns, 81.146 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.096     | 12.096     | 12.096     |   0.0 | 98.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043792   | 0.043792   | 0.043792   |   0.0 |  0.36
Output  | 9.1746e-05 | 9.1746e-05 | 9.1746e-05 |   0.0 |  0.00
Modify  | 0.15884    | 0.15884    | 0.15884    |   0.0 |  1.29
Other   |            | 0.02472    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276964.0 ave      276964 max      276964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276964
Ave neighs/atom = 138.48200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.399005888987, Press = -8.39647280460526
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -7874.256    -7874.256   -7950.1303   -7950.1303    293.64138    293.64138    23397.512    23397.512   -743.75615   -743.75615 
   11000   -7877.9178   -7877.9178   -7951.3407   -7951.3407    284.15398    284.15398    23410.232    23410.232   -2051.9222   -2051.9222 
Loop time of 11.8437 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.295 ns/day, 3.290 hours/ns, 84.433 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.633     | 11.633     | 11.633     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041584   | 0.041584   | 0.041584   |   0.0 |  0.35
Output  | 0.00019828 | 0.00019828 | 0.00019828 |   0.0 |  0.00
Modify  | 0.14638    | 0.14638    | 0.14638    |   0.0 |  1.24
Other   |            | 0.02269    |            |       |  0.19

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

Total # of neighbors = 277044
Ave neighs/atom = 138.52200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.560436208733, Press = -6.621193854762
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -7877.9178   -7877.9178   -7951.3407   -7951.3407    284.15398    284.15398    23410.232    23410.232   -2051.9222   -2051.9222 
   12000   -7877.3233   -7877.3233   -7952.2651   -7952.2651    290.03278    290.03278    23410.829    23410.829   -2414.2296   -2414.2296 
Loop time of 11.9663 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.220 ns/day, 3.324 hours/ns, 83.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    | 11.752     | 11.752     | 11.752     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042034   | 0.042034   | 0.042034   |   0.0 |  0.35
Output  | 7.9896e-05 | 7.9896e-05 | 7.9896e-05 |   0.0 |  0.00
Modify  | 0.14943    | 0.14943    | 0.14943    |   0.0 |  1.25
Other   |            | 0.02277    |            |       |  0.19

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

Total # of neighbors = 276874
Ave neighs/atom = 138.43700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.596179381119, Press = 2.86339778770156
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -7877.3233   -7877.3233   -7952.2651   -7952.2651    290.03278    290.03278    23410.829    23410.829   -2414.2296   -2414.2296 
   13000   -7873.1104   -7873.1104   -7949.9462   -7949.9462    297.36223    297.36223    23417.448    23417.448   -2482.0971   -2482.0971 
Loop time of 12.2671 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.043 ns/day, 3.408 hours/ns, 81.519 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.028     | 12.028     | 12.028     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043598   | 0.043598   | 0.043598   |   0.0 |  0.36
Output  | 8.7696e-05 | 8.7696e-05 | 8.7696e-05 |   0.0 |  0.00
Modify  | 0.17077    | 0.17077    | 0.17077    |   0.0 |  1.39
Other   |            | 0.02481    |            |       |  0.20

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

Total # of neighbors = 276908
Ave neighs/atom = 138.45400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.887466581922, Press = 6.31716194466216
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -7873.1104   -7873.1104   -7949.9462   -7949.9462    297.36223    297.36223    23417.448    23417.448   -2482.0971   -2482.0971 
   14000   -7876.4997   -7876.4997   -7952.1904   -7952.1904    292.93072    292.93072    23406.327    23406.327   -1891.2194   -1891.2194 
Loop time of 12.4646 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.932 ns/day, 3.462 hours/ns, 80.227 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.228     | 12.228     | 12.228     |   0.0 | 98.10
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045257   | 0.045257   | 0.045257   |   0.0 |  0.36
Output  | 0.00024741 | 0.00024741 | 0.00024741 |   0.0 |  0.00
Modify  | 0.16496    | 0.16496    | 0.16496    |   0.0 |  1.32
Other   |            | 0.02587    |            |       |  0.21

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

Total # of neighbors = 276788
Ave neighs/atom = 138.39400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.836801992106, Press = 12.9041264920658
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -7876.4997   -7876.4997   -7952.1904   -7952.1904    292.93072    292.93072    23406.327    23406.327   -1891.2194   -1891.2194 
   15000   -7872.0631   -7872.0631   -7949.6151   -7949.6151     300.1345     300.1345    23375.472    23375.472    598.50956    598.50956 
Loop time of 12.5885 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.863 ns/day, 3.497 hours/ns, 79.437 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    | 12.35      | 12.35      | 12.35      |   0.0 | 98.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045408   | 0.045408   | 0.045408   |   0.0 |  0.36
Output  | 0.00043042 | 0.00043042 | 0.00043042 |   0.0 |  0.00
Modify  | 0.16706    | 0.16706    | 0.16706    |   0.0 |  1.33
Other   |            | 0.02564    |            |       |  0.20

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

Total # of neighbors = 276884
Ave neighs/atom = 138.44200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.766171602507, Press = 3.39165987416492
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -7872.0631   -7872.0631   -7949.6151   -7949.6151     300.1345     300.1345    23375.472    23375.472    598.50956    598.50956 
   16000   -7876.4041   -7876.4041   -7952.6857   -7952.6857    295.21783    295.21783    23359.381    23359.381    1522.6975    1522.6975 
Loop time of 12.3229 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.011 ns/day, 3.423 hours/ns, 81.150 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.092     | 12.092     | 12.092     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044192   | 0.044192   | 0.044192   |   0.0 |  0.36
Output  | 9.8277e-05 | 9.8277e-05 | 9.8277e-05 |   0.0 |  0.00
Modify  | 0.1607     | 0.1607     | 0.1607     |   0.0 |  1.30
Other   |            | 0.02595    |            |       |  0.21

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

Total # of neighbors = 277248
Ave neighs/atom = 138.62400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.963660950415, Press = 2.16955564221837
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -7876.4041   -7876.4041   -7952.6857   -7952.6857    295.21783    295.21783    23359.381    23359.381    1522.6975    1522.6975 
   17000    -7873.379    -7873.379   -7950.8662   -7950.8662    299.88324    299.88324    23359.524    23359.524    1437.7018    1437.7018 
Loop time of 12.461 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.934 ns/day, 3.461 hours/ns, 80.250 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.228     | 12.228     | 12.228     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044521   | 0.044521   | 0.044521   |   0.0 |  0.36
Output  | 0.0001105  | 0.0001105  | 0.0001105  |   0.0 |  0.00
Modify  | 0.16284    | 0.16284    | 0.16284    |   0.0 |  1.31
Other   |            | 0.02531    |            |       |  0.20

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

Total # of neighbors = 277452
Ave neighs/atom = 138.72600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.180806061877, Press = 4.26108108643923
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -7873.379    -7873.379   -7950.8662   -7950.8662    299.88324    299.88324    23359.524    23359.524    1437.7018    1437.7018 
   18000   -7877.9713   -7877.9713    -7953.484    -7953.484    292.24186    292.24186    23357.171    23357.171    1150.8016    1150.8016 
Loop time of 12.8191 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.740 ns/day, 3.561 hours/ns, 78.009 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.574     | 12.574     | 12.574     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046671   | 0.046671   | 0.046671   |   0.0 |  0.36
Output  | 9.0281e-05 | 9.0281e-05 | 9.0281e-05 |   0.0 |  0.00
Modify  | 0.17225    | 0.17225    | 0.17225    |   0.0 |  1.34
Other   |            | 0.0261     |            |       |  0.20

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

Total # of neighbors = 277506
Ave neighs/atom = 138.75300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.185582244937, Press = 0.933015558819481
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -7877.9713   -7877.9713    -7953.484    -7953.484    292.24186    292.24186    23357.171    23357.171    1150.8016    1150.8016 
   19000   -7873.8484   -7873.8484   -7950.4899   -7950.4899    296.61049    296.61049     23322.58     23322.58    4049.5889    4049.5889 
Loop time of 12.4403 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.945 ns/day, 3.456 hours/ns, 80.384 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.208     | 12.208     | 12.208     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044293   | 0.044293   | 0.044293   |   0.0 |  0.36
Output  | 9.6455e-05 | 9.6455e-05 | 9.6455e-05 |   0.0 |  0.00
Modify  | 0.16257    | 0.16257    | 0.16257    |   0.0 |  1.31
Other   |            | 0.02512    |            |       |  0.20

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

Total # of neighbors = 277232
Ave neighs/atom = 138.61600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.056868026921, Press = -3.96830555558308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -7873.8484   -7873.8484   -7950.4899   -7950.4899    296.61049    296.61049     23322.58     23322.58    4049.5889    4049.5889 
   20000   -7880.7237   -7880.7237   -7954.6136   -7954.6136    285.96138    285.96138    23339.505    23339.505    2551.2925    2551.2925 
Loop time of 12.7291 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.788 ns/day, 3.536 hours/ns, 78.560 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.488     | 12.488     | 12.488     |   0.0 | 98.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046043   | 0.046043   | 0.046043   |   0.0 |  0.36
Output  | 8.8009e-05 | 8.8009e-05 | 8.8009e-05 |   0.0 |  0.00
Modify  | 0.16949    | 0.16949    | 0.16949    |   0.0 |  1.33
Other   |            | 0.02557    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5456.00 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277638.0 ave      277638 max      277638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277638
Ave neighs/atom = 138.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 = 293.000657878659, Press = -4.04746797005537
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -7880.7237   -7880.7237   -7954.6136   -7954.6136    285.96138    285.96138    23339.505    23339.505    2551.2925    2551.2925 
   21000   -7873.5972   -7873.5972   -7950.6729   -7950.6729    298.29075    298.29075    23377.264    23377.264    289.30444    289.30444 
Loop time of 12.3006 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.024 ns/day, 3.417 hours/ns, 81.297 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.072     | 12.072     | 12.072     |   0.0 | 98.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043968   | 0.043968   | 0.043968   |   0.0 |  0.36
Output  | 0.00018647 | 0.00018647 | 0.00018647 |   0.0 |  0.00
Modify  | 0.15943    | 0.15943    | 0.15943    |   0.0 |  1.30
Other   |            | 0.02464    |            |       |  0.20

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

Total # of neighbors = 277066
Ave neighs/atom = 138.53300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.877431225839, Press = -1.94824828861315
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -7873.5972   -7873.5972   -7950.6729   -7950.6729    298.29075    298.29075    23377.264    23377.264    289.30444    289.30444 
   22000   -7877.7817   -7877.7817   -7954.0622   -7954.0622    295.21348    295.21348    23394.126    23394.126   -1133.6401   -1133.6401 
Loop time of 12.4538 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.938 ns/day, 3.459 hours/ns, 80.297 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.219     | 12.219     | 12.219     |   0.0 | 98.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045163   | 0.045163   | 0.045163   |   0.0 |  0.36
Output  | 9.7204e-05 | 9.7204e-05 | 9.7204e-05 |   0.0 |  0.00
Modify  | 0.16348    | 0.16348    | 0.16348    |   0.0 |  1.31
Other   |            | 0.02586    |            |       |  0.21

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

Total # of neighbors = 277302
Ave neighs/atom = 138.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 = 292.892610942646, Press = -2.432814249869
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -7877.7817   -7877.7817   -7954.0622   -7954.0622    295.21348    295.21348    23394.126    23394.126   -1133.6401   -1133.6401 
   23000   -7872.8258   -7872.8258   -7950.3382   -7950.3382    299.98086    299.98086      23416.2      23416.2   -2289.4354   -2289.4354 
Loop time of 12.6009 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.857 ns/day, 3.500 hours/ns, 79.359 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.361     | 12.361     | 12.361     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045571   | 0.045571   | 0.045571   |   0.0 |  0.36
Output  | 8.8675e-05 | 8.8675e-05 | 8.8675e-05 |   0.0 |  0.00
Modify  | 0.16856    | 0.16856    | 0.16856    |   0.0 |  1.34
Other   |            | 0.0262     |            |       |  0.21

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

Total # of neighbors = 276650
Ave neighs/atom = 138.32500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.861641204736, Press = -1.33161649111828
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -7872.8258   -7872.8258   -7950.3382   -7950.3382    299.98086    299.98086      23416.2      23416.2   -2289.4354   -2289.4354 
   24000   -7875.9269   -7875.9269   -7951.2469   -7951.2469    291.49615    291.49615    23432.988    23432.988   -3644.2501   -3644.2501 
Loop time of 12.0463 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.172 ns/day, 3.346 hours/ns, 83.013 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    | 11.826     | 11.826     | 11.826     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042591   | 0.042591   | 0.042591   |   0.0 |  0.35
Output  | 8.9141e-05 | 8.9141e-05 | 8.9141e-05 |   0.0 |  0.00
Modify  | 0.15267    | 0.15267    | 0.15267    |   0.0 |  1.27
Other   |            | 0.02449    |            |       |  0.20

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

Total # of neighbors = 276960
Ave neighs/atom = 138.48000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899356626207, Press = -2.35836764080636
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -7875.9269   -7875.9269   -7951.2469   -7951.2469    291.49615    291.49615    23432.988    23432.988   -3644.2501   -3644.2501 
   25000   -7874.9136   -7874.9136   -7949.6898   -7949.6898    289.39182    289.39182    23448.953    23448.953   -4416.7278   -4416.7278 
Loop time of 11.9456 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.233 ns/day, 3.318 hours/ns, 83.713 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.728     | 11.728     | 11.728     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042231   | 0.042231   | 0.042231   |   0.0 |  0.35
Output  | 8.768e-05  | 8.768e-05  | 8.768e-05  |   0.0 |  0.00
Modify  | 0.15178    | 0.15178    | 0.15178    |   0.0 |  1.27
Other   |            | 0.02388    |            |       |  0.20

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

Total # of neighbors = 276590
Ave neighs/atom = 138.29500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.887245624511, Press = 0.17101512468747
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -7874.9136   -7874.9136   -7949.6898   -7949.6898    289.39182    289.39182    23448.953    23448.953   -4416.7278   -4416.7278 
   26000   -7870.0116   -7870.0116   -7950.2351   -7950.2351    310.47329    310.47329    23421.633    23421.633    -2527.301    -2527.301 
Loop time of 12.0445 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.173 ns/day, 3.346 hours/ns, 83.025 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.824     | 11.824     | 11.824     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04301    | 0.04301    | 0.04301    |   0.0 |  0.36
Output  | 9.0272e-05 | 9.0272e-05 | 9.0272e-05 |   0.0 |  0.00
Modify  | 0.15358    | 0.15358    | 0.15358    |   0.0 |  1.28
Other   |            | 0.02379    |            |       |  0.20

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

Total # of neighbors = 276366
Ave neighs/atom = 138.18300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.055411573135, Press = 1.09986146146105
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -7870.0116   -7870.0116   -7950.2351   -7950.2351    310.47329    310.47329    23421.633    23421.633    -2527.301    -2527.301 
   27000   -7876.0159   -7876.0159   -7952.2298   -7952.2298    294.95532    294.95532    23396.566    23396.566   -1058.2017   -1058.2017 
Loop time of 12.5148 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.904 ns/day, 3.476 hours/ns, 79.905 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    | 12.282     | 12.282     | 12.282     |   0.0 | 98.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044557   | 0.044557   | 0.044557   |   0.0 |  0.36
Output  | 8.8486e-05 | 8.8486e-05 | 8.8486e-05 |   0.0 |  0.00
Modify  | 0.16315    | 0.16315    | 0.16315    |   0.0 |  1.30
Other   |            | 0.02468    |            |       |  0.20

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

Total # of neighbors = 276862
Ave neighs/atom = 138.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 = 293.106760725592, Press = 0.855596672024206
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -7876.0159   -7876.0159   -7952.2298   -7952.2298    294.95532    294.95532    23396.566    23396.566   -1058.2017   -1058.2017 
   28000   -7874.2557   -7874.2557   -7951.2987   -7951.2987    298.16436    298.16436    23362.322    23362.322    1268.4523    1268.4523 
Loop time of 12.1894 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.088 ns/day, 3.386 hours/ns, 82.038 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.964     | 11.964     | 11.964     |   0.0 | 98.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043386   | 0.043386   | 0.043386   |   0.0 |  0.36
Output  | 9.0726e-05 | 9.0726e-05 | 9.0726e-05 |   0.0 |  0.00
Modify  | 0.15777    | 0.15777    | 0.15777    |   0.0 |  1.29
Other   |            | 0.02442    |            |       |  0.20

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

Total # of neighbors = 276694
Ave neighs/atom = 138.34700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.193884405514, Press = 1.46594290633086
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -7874.2557   -7874.2557   -7951.2987   -7951.2987    298.16436    298.16436    23362.322    23362.322    1268.4523    1268.4523 
   29000   -7876.9163   -7876.9163   -7953.1511   -7953.1511    295.03658    295.03658    23341.853    23341.853    2525.2742    2525.2742 
Loop time of 11.9757 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.215 ns/day, 3.327 hours/ns, 83.502 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.758     | 11.758     | 11.758     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042425   | 0.042425   | 0.042425   |   0.0 |  0.35
Output  | 7.6209e-05 | 7.6209e-05 | 7.6209e-05 |   0.0 |  0.00
Modify  | 0.15186    | 0.15186    | 0.15186    |   0.0 |  1.27
Other   |            | 0.0236     |            |       |  0.20

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

Total # of neighbors = 277454
Ave neighs/atom = 138.72700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.191118660005, Press = -0.496710450177698
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -7876.9163   -7876.9163   -7953.1511   -7953.1511    295.03658    295.03658    23341.853    23341.853    2525.2742    2525.2742 
   30000   -7874.9296   -7874.9296   -7950.0143   -7950.0143    290.58527    290.58527    23350.246    23350.246    2324.4796    2324.4796 
Loop time of 12.3135 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.017 ns/day, 3.420 hours/ns, 81.212 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    | 12.083     | 12.083     | 12.083     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044061   | 0.044061   | 0.044061   |   0.0 |  0.36
Output  | 9.1297e-05 | 9.1297e-05 | 9.1297e-05 |   0.0 |  0.00
Modify  | 0.16055    | 0.16055    | 0.16055    |   0.0 |  1.30
Other   |            | 0.02551    |            |       |  0.21

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

Total # of neighbors = 277372
Ave neighs/atom = 138.68600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.155109723905, Press = -1.36395882555782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -7874.9296   -7874.9296   -7950.0143   -7950.0143    290.58527    290.58527    23350.246    23350.246    2324.4796    2324.4796 
   31000   -7878.3785   -7878.3785   -7952.3612   -7952.3612     286.3208     286.3208    23371.096    23371.096    467.97288    467.97288 
Loop time of 12.1779 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.095 ns/day, 3.383 hours/ns, 82.116 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.954     | 11.954     | 11.954     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043216   | 0.043216   | 0.043216   |   0.0 |  0.35
Output  | 9.7873e-05 | 9.7873e-05 | 9.7873e-05 |   0.0 |  0.00
Modify  | 0.15661    | 0.15661    | 0.15661    |   0.0 |  1.29
Other   |            | 0.02404    |            |       |  0.20

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

Total # of neighbors = 277488
Ave neighs/atom = 138.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 = 293.224236997174, Press = -3.16314442910346
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -7878.3785   -7878.3785   -7952.3612   -7952.3612     286.3208     286.3208    23371.096    23371.096    467.97288    467.97288 
   32000    -7874.941    -7874.941   -7951.5098   -7951.5098    296.32914    296.32914    23382.176    23382.176    457.61829    457.61829 
Loop time of 12.383 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.977 ns/day, 3.440 hours/ns, 80.756 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.153     | 12.153     | 12.153     |   0.0 | 98.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044337   | 0.044337   | 0.044337   |   0.0 |  0.36
Output  | 8.6046e-05 | 8.6046e-05 | 8.6046e-05 |   0.0 |  0.00
Modify  | 0.16143    | 0.16143    | 0.16143    |   0.0 |  1.30
Other   |            | 0.02455    |            |       |  0.20

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

Total # of neighbors = 277322
Ave neighs/atom = 138.66100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.178585268991, Press = -1.28835234146419
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -7874.941    -7874.941   -7951.5098   -7951.5098    296.32914    296.32914    23382.176    23382.176    457.61829    457.61829 
   33000   -7878.2976   -7878.2976    -7952.766    -7952.766    288.20062    288.20062    23392.476    23392.476   -1102.6775   -1102.6775 
Loop time of 12.082 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.151 ns/day, 3.356 hours/ns, 82.768 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    | 11.863     | 11.863     | 11.863     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042672   | 0.042672   | 0.042672   |   0.0 |  0.35
Output  | 9.396e-05  | 9.396e-05  | 9.396e-05  |   0.0 |  0.00
Modify  | 0.15276    | 0.15276    | 0.15276    |   0.0 |  1.26
Other   |            | 0.02391    |            |       |  0.20

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

Total # of neighbors = 276806
Ave neighs/atom = 138.40300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.103056609544, Press = -0.878781500201899
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -7878.2976   -7878.2976    -7952.766    -7952.766    288.20062    288.20062    23392.476    23392.476   -1102.6775   -1102.6775 
   34000   -7875.0919   -7875.0919   -7951.6978   -7951.6978    296.47284    296.47284    23429.517    23429.517   -2881.3792   -2881.3792 
Loop time of 12.6047 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.855 ns/day, 3.501 hours/ns, 79.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.368     | 12.368     | 12.368     |   0.0 | 98.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045229   | 0.045229   | 0.045229   |   0.0 |  0.36
Output  | 6.4373e-05 | 6.4373e-05 | 6.4373e-05 |   0.0 |  0.00
Modify  | 0.16648    | 0.16648    | 0.16648    |   0.0 |  1.32
Other   |            | 0.02517    |            |       |  0.20

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

Total # of neighbors = 277154
Ave neighs/atom = 138.57700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.116833876265, Press = -1.11538790972265
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -7875.0919   -7875.0919   -7951.6978   -7951.6978    296.47284    296.47284    23429.517    23429.517   -2881.3792   -2881.3792 
   35000    -7877.395    -7877.395   -7950.8837   -7950.8837    284.40862    284.40862     23423.86     23423.86   -2678.8833   -2678.8833 
Loop time of 12.3173 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.015 ns/day, 3.421 hours/ns, 81.187 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.09      | 12.09      | 12.09      |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043727   | 0.043727   | 0.043727   |   0.0 |  0.36
Output  | 9.0038e-05 | 9.0038e-05 | 9.0038e-05 |   0.0 |  0.00
Modify  | 0.1588     | 0.1588     | 0.1588     |   0.0 |  1.29
Other   |            | 0.02435    |            |       |  0.20

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

Total # of neighbors = 276338
Ave neighs/atom = 138.16900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.131947415242, Press = 0.91926690211976
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -7877.395    -7877.395   -7950.8837   -7950.8837    284.40862    284.40862     23423.86     23423.86   -2678.8833   -2678.8833 
   36000   -7875.1359   -7875.1359   -7951.7892   -7951.7892    296.65651    296.65651    23417.388    23417.388   -2205.9314   -2205.9314 
Loop time of 12.2668 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.043 ns/day, 3.407 hours/ns, 81.521 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.04      | 12.04      | 12.04      |   0.0 | 98.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04365    | 0.04365    | 0.04365    |   0.0 |  0.36
Output  | 9.0131e-05 | 9.0131e-05 | 9.0131e-05 |   0.0 |  0.00
Modify  | 0.15868    | 0.15868    | 0.15868    |   0.0 |  1.29
Other   |            | 0.02462    |            |       |  0.20

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

Total # of neighbors = 276588
Ave neighs/atom = 138.29400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.144940579914, Press = 2.0384382179827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -7875.1359   -7875.1359   -7951.7892   -7951.7892    296.65651    296.65651    23417.388    23417.388   -2205.9314   -2205.9314 
   37000   -7876.3028   -7876.3028   -7949.5646   -7949.5646    283.53085    283.53085    23414.813    23414.813   -1823.7708   -1823.7708 
Loop time of 12.2951 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.027 ns/day, 3.415 hours/ns, 81.333 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.066     | 12.066     | 12.066     |   0.0 | 98.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044097   | 0.044097   | 0.044097   |   0.0 |  0.36
Output  | 8.2625e-05 | 8.2625e-05 | 8.2625e-05 |   0.0 |  0.00
Modify  | 0.16012    | 0.16012    | 0.16012    |   0.0 |  1.30
Other   |            | 0.02466    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276704.0 ave      276704 max      276704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276704
Ave neighs/atom = 138.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 = 293.161705382797, Press = 2.69646416388861
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -7876.3028   -7876.3028   -7949.5646   -7949.5646    283.53085    283.53085    23414.813    23414.813   -1823.7708   -1823.7708 
   38000   -7872.2738   -7872.2738   -7949.5223   -7949.5223    298.95982    298.95982    23386.596    23386.596    178.20974    178.20974 
Loop time of 12.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.154 ns/day, 3.355 hours/ns, 82.802 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.856     | 11.856     | 11.856     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042478   | 0.042478   | 0.042478   |   0.0 |  0.35
Output  | 9.1005e-05 | 9.1005e-05 | 9.1005e-05 |   0.0 |  0.00
Modify  | 0.15422    | 0.15422    | 0.15422    |   0.0 |  1.28
Other   |            | 0.02385    |            |       |  0.20

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

Total # of neighbors = 276798
Ave neighs/atom = 138.39900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.251591080703, Press = 1.86801399637884
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -7872.2738   -7872.2738   -7949.5223   -7949.5223    298.95982    298.95982    23386.596    23386.596    178.20974    178.20974 
   39000   -7876.9719   -7876.9719   -7952.9583   -7952.9583     294.0752     294.0752     23389.02     23389.02   -668.49489   -668.49489 
Loop time of 12.4308 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.951 ns/day, 3.453 hours/ns, 80.446 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.199     | 12.199     | 12.199     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044546   | 0.044546   | 0.044546   |   0.0 |  0.36
Output  | 6.121e-05  | 6.121e-05  | 6.121e-05  |   0.0 |  0.00
Modify  | 0.16292    | 0.16292    | 0.16292    |   0.0 |  1.31
Other   |            | 0.0247     |            |       |  0.20

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

Total # of neighbors = 277188
Ave neighs/atom = 138.59400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.284323083716, Press = 1.15775087768008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -7876.9719   -7876.9719   -7952.9583   -7952.9583     294.0752     294.0752     23389.02     23389.02   -668.49489   -668.49489 
   40000   -7874.9683   -7874.9683   -7948.7646   -7948.7646    285.59916    285.59916    23390.689    23390.689   -606.27946   -606.27946 
Loop time of 12.1706 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.099 ns/day, 3.381 hours/ns, 82.165 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.947     | 11.947     | 11.947     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043176   | 0.043176   | 0.043176   |   0.0 |  0.35
Output  | 6.0078e-05 | 6.0078e-05 | 6.0078e-05 |   0.0 |  0.00
Modify  | 0.15604    | 0.15604    | 0.15604    |   0.0 |  1.28
Other   |            | 0.02395    |            |       |  0.20

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

Total # of neighbors = 276912
Ave neighs/atom = 138.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 = 293.327646516948, Press = 0.839300046714353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -7874.9683   -7874.9683   -7948.7646   -7948.7646    285.59916    285.59916    23390.689    23390.689   -606.27946   -606.27946 
   41000   -7873.0152   -7873.0152   -7951.1642   -7951.1642    302.44475    302.44475    23372.079    23372.079    990.11763    990.11763 
Loop time of 12.0654 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.161 ns/day, 3.352 hours/ns, 82.881 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.845     | 11.845     | 11.845     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042586   | 0.042586   | 0.042586   |   0.0 |  0.35
Output  | 8.8251e-05 | 8.8251e-05 | 8.8251e-05 |   0.0 |  0.00
Modify  | 0.15413    | 0.15413    | 0.15413    |   0.0 |  1.28
Other   |            | 0.02344    |            |       |  0.19

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

Total # of neighbors = 277390
Ave neighs/atom = 138.69500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.314087519953, Press = 0.908627442265464
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -7873.0152   -7873.0152   -7951.1642   -7951.1642    302.44475    302.44475    23372.079    23372.079    990.11763    990.11763 
   42000   -7875.5089   -7875.5089    -7952.795    -7952.795    299.10515    299.10515    23347.166    23347.166    2625.7363    2625.7363 
Loop time of 12.5776 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.869 ns/day, 3.494 hours/ns, 79.507 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    | 12.341     | 12.341     | 12.341     |   0.0 | 98.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045192   | 0.045192   | 0.045192   |   0.0 |  0.36
Output  | 6.239e-05  | 6.239e-05  | 6.239e-05  |   0.0 |  0.00
Modify  | 0.16602    | 0.16602    | 0.16602    |   0.0 |  1.32
Other   |            | 0.02496    |            |       |  0.20

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

Total # of neighbors = 277044
Ave neighs/atom = 138.52200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.319222811304, Press = 1.23283163660979
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -7875.5089   -7875.5089    -7952.795    -7952.795    299.10515    299.10515    23347.166    23347.166    2625.7363    2625.7363 
   43000   -7872.5497   -7872.5497   -7948.8832   -7948.8832    295.41865    295.41865    23359.192    23359.192    1919.4297    1919.4297 
Loop time of 11.8345 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.301 ns/day, 3.287 hours/ns, 84.499 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.623     | 11.623     | 11.623     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041762   | 0.041762   | 0.041762   |   0.0 |  0.35
Output  | 8.6149e-05 | 8.6149e-05 | 8.6149e-05 |   0.0 |  0.00
Modify  | 0.14697    | 0.14697    | 0.14697    |   0.0 |  1.24
Other   |            | 0.02246    |            |       |  0.19

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

Total # of neighbors = 277268
Ave neighs/atom = 138.63400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.386449978675, Press = -0.151434229926245
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -7872.5497   -7872.5497   -7948.8832   -7948.8832    295.41865    295.41865    23359.192    23359.192    1919.4297    1919.4297 
   44000   -7875.0284   -7875.0284   -7950.4117   -7950.4117    291.74112    291.74112    23353.124    23353.124    2357.6678    2357.6678 
Loop time of 11.9134 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.252 ns/day, 3.309 hours/ns, 83.939 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.7       | 11.7       | 11.7       |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041826   | 0.041826   | 0.041826   |   0.0 |  0.35
Output  | 8.8106e-05 | 8.8106e-05 | 8.8106e-05 |   0.0 |  0.00
Modify  | 0.14907    | 0.14907    | 0.14907    |   0.0 |  1.25
Other   |            | 0.02256    |            |       |  0.19

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

Total # of neighbors = 277718
Ave neighs/atom = 138.85900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.373033610069, Press = -0.590635169433181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -7875.0284   -7875.0284   -7950.4117   -7950.4117    291.74112    291.74112    23353.124    23353.124    2357.6678    2357.6678 
   45000   -7875.7264   -7875.7264   -7949.1277   -7949.1277    284.07054    284.07054     23370.98     23370.98    1204.3397    1204.3397 
Loop time of 12.2086 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.077 ns/day, 3.391 hours/ns, 81.910 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.983     | 11.983     | 11.983     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043573   | 0.043573   | 0.043573   |   0.0 |  0.36
Output  | 8.8742e-05 | 8.8742e-05 | 8.8742e-05 |   0.0 |  0.00
Modify  | 0.15763    | 0.15763    | 0.15763    |   0.0 |  1.29
Other   |            | 0.02385    |            |       |  0.20

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

Total # of neighbors = 277314
Ave neighs/atom = 138.65700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.391523548783, Press = -1.2533834962824
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -7875.7264   -7875.7264   -7949.1277   -7949.1277    284.07054    284.07054     23370.98     23370.98    1204.3397    1204.3397 
   46000   -7874.7992   -7874.7992   -7950.7989   -7950.7989     294.1266     294.1266    23386.004    23386.004   -1.5853916   -1.5853916 
Loop time of 11.7416 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.358 ns/day, 3.262 hours/ns, 85.167 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.532     | 11.532     | 11.532     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041312   | 0.041312   | 0.041312   |   0.0 |  0.35
Output  | 8.823e-05  | 8.823e-05  | 8.823e-05  |   0.0 |  0.00
Modify  | 0.14609    | 0.14609    | 0.14609    |   0.0 |  1.24
Other   |            | 0.0225     |            |       |  0.19

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

Total # of neighbors = 277342
Ave neighs/atom = 138.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 = 293.37194305311, Press = -0.408991533095137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -7874.7992   -7874.7992   -7950.7989   -7950.7989     294.1266     294.1266    23386.004    23386.004   -1.5853916   -1.5853916 
   47000   -7877.6604   -7877.6604   -7952.9274   -7952.9274    291.29102    291.29102    23396.936    23396.936   -736.11778   -736.11778 
Loop time of 11.8177 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.311 ns/day, 3.283 hours/ns, 84.619 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.606     | 11.606     | 11.606     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041754   | 0.041754   | 0.041754   |   0.0 |  0.35
Output  | 7.8121e-05 | 7.8121e-05 | 7.8121e-05 |   0.0 |  0.00
Modify  | 0.14733    | 0.14733    | 0.14733    |   0.0 |  1.25
Other   |            | 0.02265    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5466.00 ave        5466 max        5466 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277022.0 ave      277022 max      277022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277022
Ave neighs/atom = 138.51100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.38503737564, Press = -0.0516878421742894
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -7877.6604   -7877.6604   -7952.9274   -7952.9274    291.29102    291.29102    23396.936    23396.936   -736.11778   -736.11778 
   48000    -7871.392    -7871.392   -7951.0487   -7951.0487    308.27992    308.27992    23397.139    23397.139   -804.23177   -804.23177 
Loop time of 11.9521 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.229 ns/day, 3.320 hours/ns, 83.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    | 11.736     | 11.736     | 11.736     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042025   | 0.042025   | 0.042025   |   0.0 |  0.35
Output  | 8.4602e-05 | 8.4602e-05 | 8.4602e-05 |   0.0 |  0.00
Modify  | 0.15047    | 0.15047    | 0.15047    |   0.0 |  1.26
Other   |            | 0.02316    |            |       |  0.19

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

Total # of neighbors = 276642
Ave neighs/atom = 138.32100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.399178982679, Press = 0.544614213407027
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -7871.392    -7871.392   -7951.0487   -7951.0487    308.27992    308.27992    23397.139    23397.139   -804.23177   -804.23177 
   49000   -7875.5059   -7875.5059   -7952.9829   -7952.9829    299.84418    299.84418    23384.082    23384.082   -225.43158   -225.43158 
Loop time of 12.1154 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.131 ns/day, 3.365 hours/ns, 82.540 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.892     | 11.892     | 11.892     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042918   | 0.042918   | 0.042918   |   0.0 |  0.35
Output  | 8.1049e-05 | 8.1049e-05 | 8.1049e-05 |   0.0 |  0.00
Modify  | 0.15686    | 0.15686    | 0.15686    |   0.0 |  1.29
Other   |            | 0.02325    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5466.00 ave        5466 max        5466 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276818.0 ave      276818 max      276818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276818
Ave neighs/atom = 138.40900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.431469409285, Press = 1.53230898313534
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -7875.5059   -7875.5059   -7952.9829   -7952.9829    299.84418    299.84418    23384.082    23384.082   -225.43158   -225.43158 
   50000   -7874.8341   -7874.8341   -7950.5581   -7950.5581    293.05982    293.05982    23351.735    23351.735    2508.4872    2508.4872 
Loop time of 11.6062 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.444 ns/day, 3.224 hours/ns, 86.161 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.401     | 11.401     | 11.401     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040442   | 0.040442   | 0.040442   |   0.0 |  0.35
Output  | 8.721e-05  | 8.721e-05  | 8.721e-05  |   0.0 |  0.00
Modify  | 0.14292    | 0.14292    | 0.14292    |   0.0 |  1.23
Other   |            | 0.02213    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277028.0 ave      277028 max      277028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277028
Ave neighs/atom = 138.51400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.461879668365, Press = 2.41291280767674
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -7874.8341   -7874.8341   -7950.5581   -7950.5581    293.05982    293.05982    23351.735    23351.735    2508.4872    2508.4872 
   51000   -7873.9254   -7873.9254   -7949.5261   -7949.5261    292.58238    292.58238    23338.125    23338.125    3562.2463    3562.2463 
Loop time of 11.505 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.510 ns/day, 3.196 hours/ns, 86.918 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.303     | 11.303     | 11.303     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040048   | 0.040048   | 0.040048   |   0.0 |  0.35
Output  | 8.8865e-05 | 8.8865e-05 | 8.8865e-05 |   0.0 |  0.00
Modify  | 0.14047    | 0.14047    | 0.14047    |   0.0 |  1.22
Other   |            | 0.02111    |            |       |  0.18

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

Total # of neighbors = 277278
Ave neighs/atom = 138.63900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.472832205125, Press = 1.52669162746893
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -7873.9254   -7873.9254   -7949.5261   -7949.5261    292.58238    292.58238    23338.125    23338.125    3562.2463    3562.2463 
   52000   -7875.8077   -7875.8077   -7950.9179   -7950.9179    290.68417    290.68417    23356.956    23356.956    1950.2601    1950.2601 
Loop time of 11.4825 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.282     | 11.282     | 11.282     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040019   | 0.040019   | 0.040019   |   0.0 |  0.35
Output  | 6.3576e-05 | 6.3576e-05 | 6.3576e-05 |   0.0 |  0.00
Modify  | 0.13936    | 0.13936    | 0.13936    |   0.0 |  1.21
Other   |            | 0.02123    |            |       |  0.18

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

Total # of neighbors = 277628
Ave neighs/atom = 138.81400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.532536772295, Press = 0.477593072830501
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -7875.8077   -7875.8077   -7950.9179   -7950.9179    290.68417    290.68417    23356.956    23356.956    1950.2601    1950.2601 
   53000   -7872.2691   -7872.2691   -7949.6571   -7949.6571    299.49953    299.49953    23357.714    23357.714    1958.4747    1958.4747 
Loop time of 11.5182 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.501 ns/day, 3.199 hours/ns, 86.819 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.316     | 11.316     | 11.316     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040023   | 0.040023   | 0.040023   |   0.0 |  0.35
Output  | 9.0738e-05 | 9.0738e-05 | 9.0738e-05 |   0.0 |  0.00
Modify  | 0.14077    | 0.14077    | 0.14077    |   0.0 |  1.22
Other   |            | 0.02157    |            |       |  0.19

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

Total # of neighbors = 277498
Ave neighs/atom = 138.74900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.551891627826, Press = 0.116009035920741
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -7872.2691   -7872.2691   -7949.6571   -7949.6571    299.49953    299.49953    23357.714    23357.714    1958.4747    1958.4747 
   54000   -7877.2036   -7877.2036   -7951.9159   -7951.9159    289.14444    289.14444    23357.538    23357.538    1874.3211    1874.3211 
Loop time of 11.5086 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.507 ns/day, 3.197 hours/ns, 86.892 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.308     | 11.308     | 11.308     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039794   | 0.039794   | 0.039794   |   0.0 |  0.35
Output  | 0.00012168 | 0.00012168 | 0.00012168 |   0.0 |  0.00
Modify  | 0.1394     | 0.1394     | 0.1394     |   0.0 |  1.21
Other   |            | 0.02101    |            |       |  0.18

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

Total # of neighbors = 277826
Ave neighs/atom = 138.91300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.590768031228, Press = -0.162714715376685
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -7877.2036   -7877.2036   -7951.9159   -7951.9159    289.14444    289.14444    23357.538    23357.538    1874.3211    1874.3211 
   55000   -7874.7016   -7874.7016   -7950.3258   -7950.3258    292.67374    292.67374    23377.617    23377.617    665.83713    665.83713 
Loop time of 11.4924 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.518 ns/day, 3.192 hours/ns, 87.014 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.292     | 11.292     | 11.292     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039861   | 0.039861   | 0.039861   |   0.0 |  0.35
Output  | 8.3086e-05 | 8.3086e-05 | 8.3086e-05 |   0.0 |  0.00
Modify  | 0.13933    | 0.13933    | 0.13933    |   0.0 |  1.21
Other   |            | 0.02102    |            |       |  0.18

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

Total # of neighbors = 277164
Ave neighs/atom = 138.58200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.593321289533, Press = -0.413928027812585
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -7874.7016   -7874.7016   -7950.3258   -7950.3258    292.67374    292.67374    23377.617    23377.617    665.83713    665.83713 
   56000   -7873.4616   -7873.4616   -7948.8533   -7948.8533     291.7736     291.7736    23385.091    23385.091     361.5279     361.5279 
Loop time of 11.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.525 ns/day, 3.189 hours/ns, 87.093 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.282     | 11.282     | 11.282     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039758   | 0.039758   | 0.039758   |   0.0 |  0.35
Output  | 6.0856e-05 | 6.0856e-05 | 6.0856e-05 |   0.0 |  0.00
Modify  | 0.13911    | 0.13911    | 0.13911    |   0.0 |  1.21
Other   |            | 0.02108    |            |       |  0.18

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

Total # of neighbors = 277112
Ave neighs/atom = 138.55600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.591589661433, Press = -0.52361235046309
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -7873.4616   -7873.4616   -7948.8533   -7948.8533     291.7736     291.7736    23385.091    23385.091     361.5279     361.5279 
   57000   -7877.7529   -7877.7529   -7952.5778   -7952.5778    289.57993    289.57993    23379.423    23379.423    326.62478    326.62478 
Loop time of 11.4918 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.518 ns/day, 3.192 hours/ns, 87.018 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.292     | 11.292     | 11.292     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039803   | 0.039803   | 0.039803   |   0.0 |  0.35
Output  | 9.5455e-05 | 9.5455e-05 | 9.5455e-05 |   0.0 |  0.00
Modify  | 0.13905    | 0.13905    | 0.13905    |   0.0 |  1.21
Other   |            | 0.02099    |            |       |  0.18

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

Total # of neighbors = 277178
Ave neighs/atom = 138.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 = 293.596229997895, Press = -0.296943462958447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -7877.7529   -7877.7529   -7952.5778   -7952.5778    289.57993    289.57993    23379.423    23379.423    326.62478    326.62478 
   58000   -7875.2524   -7875.2524   -7951.2013   -7951.2013    293.93011    293.93011    23381.481    23381.481    96.465047    96.465047 
Loop time of 11.7331 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.364 ns/day, 3.259 hours/ns, 85.229 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.524     | 11.524     | 11.524     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04082    | 0.04082    | 0.04082    |   0.0 |  0.35
Output  | 8.4106e-05 | 8.4106e-05 | 8.4106e-05 |   0.0 |  0.00
Modify  | 0.14551    | 0.14551    | 0.14551    |   0.0 |  1.24
Other   |            | 0.02225    |            |       |  0.19

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

Total # of neighbors = 276970
Ave neighs/atom = 138.48500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.566386453488, Press = -0.8215099362673
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -7875.2524   -7875.2524   -7951.2013   -7951.2013    293.93011    293.93011    23381.481    23381.481    96.465047    96.465047 
   59000   -7875.0144   -7875.0144   -7950.7692   -7950.7692     293.1786     293.1786    23397.472    23397.472   -673.79904   -673.79904 
Loop time of 11.6759 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.400 ns/day, 3.243 hours/ns, 85.647 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.467     | 11.467     | 11.467     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041368   | 0.041368   | 0.041368   |   0.0 |  0.35
Output  | 6.2289e-05 | 6.2289e-05 | 6.2289e-05 |   0.0 |  0.00
Modify  | 0.14486    | 0.14486    | 0.14486    |   0.0 |  1.24
Other   |            | 0.02284    |            |       |  0.20

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

Total # of neighbors = 277080
Ave neighs/atom = 138.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 = 293.503078814548, Press = -1.59631408872309
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -7875.0144   -7875.0144   -7950.7692   -7950.7692     293.1786     293.1786    23397.472    23397.472   -673.79904   -673.79904 
   60000    -7877.722    -7877.722   -7952.1728   -7952.1728    288.13238    288.13238    23407.227    23407.227   -1555.7045   -1555.7045 
Loop time of 11.5312 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.493 ns/day, 3.203 hours/ns, 86.722 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.329     | 11.329     | 11.329     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04012    | 0.04012    | 0.04012    |   0.0 |  0.35
Output  | 6.5705e-05 | 6.5705e-05 | 6.5705e-05 |   0.0 |  0.00
Modify  | 0.1406     | 0.1406     | 0.1406     |   0.0 |  1.22
Other   |            | 0.02127    |            |       |  0.18

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

Total # of neighbors = 276700
Ave neighs/atom = 138.35000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.483745303405, Press = -0.984711652285575
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000    -7877.722    -7877.722   -7952.1728   -7952.1728    288.13238    288.13238    23407.227    23407.227   -1555.7045   -1555.7045 
   61000   -7877.9699   -7877.9699   -7954.5386   -7954.5386    296.32885    296.32885    23391.576    23391.576   -890.39362   -890.39362 
Loop time of 11.5076 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.508 ns/day, 3.197 hours/ns, 86.899 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.305     | 11.305     | 11.305     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04013    | 0.04013    | 0.04013    |   0.0 |  0.35
Output  | 5.8688e-05 | 5.8688e-05 | 5.8688e-05 |   0.0 |  0.00
Modify  | 0.14083    | 0.14083    | 0.14083    |   0.0 |  1.22
Other   |            | 0.02123    |            |       |  0.18

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

Total # of neighbors = 276730
Ave neighs/atom = 138.36500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.472847787897, Press = -0.0881263881270543
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -7877.9699   -7877.9699   -7954.5386   -7954.5386    296.32885    296.32885    23391.576    23391.576   -890.39362   -890.39362 
   62000   -7876.0119   -7876.0119   -7950.7384   -7950.7384    289.19942    289.19942    23396.191    23396.191   -871.40154   -871.40154 
Loop time of 11.6695 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.404 ns/day, 3.242 hours/ns, 85.694 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.462     | 11.462     | 11.462     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040667   | 0.040667   | 0.040667   |   0.0 |  0.35
Output  | 9.5801e-05 | 9.5801e-05 | 9.5801e-05 |   0.0 |  0.00
Modify  | 0.14471    | 0.14471    | 0.14471    |   0.0 |  1.24
Other   |            | 0.0219     |            |       |  0.19

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

Total # of neighbors = 276734
Ave neighs/atom = 138.36700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.470474162575, Press = 0.361660213021011
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -7876.0119   -7876.0119   -7950.7384   -7950.7384    289.19942    289.19942    23396.191    23396.191   -871.40154   -871.40154 
   63000   -7872.7984   -7872.7984    -7948.966    -7948.966    294.77661    294.77661    23379.461    23379.461    502.49053    502.49053 
Loop time of 11.5141 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.504 ns/day, 3.198 hours/ns, 86.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.313     | 11.313     | 11.313     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039969   | 0.039969   | 0.039969   |   0.0 |  0.35
Output  | 6.092e-05  | 6.092e-05  | 6.092e-05  |   0.0 |  0.00
Modify  | 0.1399     | 0.1399     | 0.1399     |   0.0 |  1.22
Other   |            | 0.02101    |            |       |  0.18

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

Total # of neighbors = 277166
Ave neighs/atom = 138.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 = 293.469855405242, Press = -0.0468904985603812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -7872.7984   -7872.7984    -7948.966    -7948.966    294.77661    294.77661    23379.461    23379.461    502.49053    502.49053 
   64000   -7876.8387   -7876.8387   -7953.2749   -7953.2749    295.81611    295.81611    23364.274    23364.274    1462.3987    1462.3987 
Loop time of 11.5353 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.490 ns/day, 3.204 hours/ns, 86.690 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.333     | 11.333     | 11.333     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040166   | 0.040166   | 0.040166   |   0.0 |  0.35
Output  | 6.073e-05  | 6.073e-05  | 6.073e-05  |   0.0 |  0.00
Modify  | 0.14109    | 0.14109    | 0.14109    |   0.0 |  1.22
Other   |            | 0.02146    |            |       |  0.19

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

Total # of neighbors = 277496
Ave neighs/atom = 138.74800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.453542835012, Press = -0.164283016264262
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -7876.8387   -7876.8387   -7953.2749   -7953.2749    295.81611    295.81611    23364.274    23364.274    1462.3987    1462.3987 
   65000     -7874.66     -7874.66   -7950.5068   -7950.5068    293.53501    293.53501    23355.229    23355.229    2084.8958    2084.8958 
Loop time of 11.5088 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.507 ns/day, 3.197 hours/ns, 86.890 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.308     | 11.308     | 11.308     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040068   | 0.040068   | 0.040068   |   0.0 |  0.35
Output  | 6.3212e-05 | 6.3212e-05 | 6.3212e-05 |   0.0 |  0.00
Modify  | 0.13965    | 0.13965    | 0.13965    |   0.0 |  1.21
Other   |            | 0.02106    |            |       |  0.18

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

Total # of neighbors = 277054
Ave neighs/atom = 138.52700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.454727264537, Press = -1.11647442176215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000     -7874.66     -7874.66   -7950.5068   -7950.5068    293.53501    293.53501    23355.229    23355.229    2084.8958    2084.8958 
   66000   -7874.4614   -7874.4614   -7953.2661   -7953.2661    304.98236    304.98236    23374.388    23374.388    440.91485    440.91485 
Loop time of 11.5083 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.508 ns/day, 3.197 hours/ns, 86.894 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.307     | 11.307     | 11.307     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039994   | 0.039994   | 0.039994   |   0.0 |  0.35
Output  | 7.2375e-05 | 7.2375e-05 | 7.2375e-05 |   0.0 |  0.00
Modify  | 0.13956    | 0.13956    | 0.13956    |   0.0 |  1.21
Other   |            | 0.02125    |            |       |  0.18

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

Total # of neighbors = 277572
Ave neighs/atom = 138.78600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.450186171014, Press = -0.868799613515638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -7874.4614   -7874.4614   -7953.2661   -7953.2661    304.98236    304.98236    23374.388    23374.388    440.91485    440.91485 
   67000   -7875.8587   -7875.8587   -7951.6655   -7951.6655    293.38007    293.38007     23390.45     23390.45   -706.15424   -706.15424 
Loop time of 11.5006 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.513 ns/day, 3.195 hours/ns, 86.952 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.3       | 11.3       | 11.3       |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039817   | 0.039817   | 0.039817   |   0.0 |  0.35
Output  | 9.5525e-05 | 9.5525e-05 | 9.5525e-05 |   0.0 |  0.00
Modify  | 0.13987    | 0.13987    | 0.13987    |   0.0 |  1.22
Other   |            | 0.0212     |            |       |  0.18

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

Total # of neighbors = 277080
Ave neighs/atom = 138.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 = 293.48316709411, Press = -0.771886885469169
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -7875.8587   -7875.8587   -7951.6655   -7951.6655    293.38007    293.38007     23390.45     23390.45   -706.15424   -706.15424 
   68000   -7873.5413   -7873.5413   -7951.6709   -7951.6709     302.3699     302.3699    23394.944    23394.944   -669.83419   -669.83419 
Loop time of 11.4761 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.529 ns/day, 3.188 hours/ns, 87.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.276     | 11.276     | 11.276     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039822   | 0.039822   | 0.039822   |   0.0 |  0.35
Output  | 8.4969e-05 | 8.4969e-05 | 8.4969e-05 |   0.0 |  0.00
Modify  | 0.1394     | 0.1394     | 0.1394     |   0.0 |  1.21
Other   |            | 0.02095    |            |       |  0.18

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

Total # of neighbors = 276730
Ave neighs/atom = 138.36500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.504649133839, Press = -0.269926271888256
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -7873.5413   -7873.5413   -7951.6709   -7951.6709     302.3699     302.3699    23394.944    23394.944   -669.83419   -669.83419 
   69000   -7877.4741   -7877.4741   -7952.1341   -7952.1341    288.94202    288.94202    23399.111    23399.111   -988.01783   -988.01783 
Loop time of 11.4797 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.526 ns/day, 3.189 hours/ns, 87.110 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.279     | 11.279     | 11.279     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039911   | 0.039911   | 0.039911   |   0.0 |  0.35
Output  | 8.2707e-05 | 8.2707e-05 | 8.2707e-05 |   0.0 |  0.00
Modify  | 0.13927    | 0.13927    | 0.13927    |   0.0 |  1.21
Other   |            | 0.02107    |            |       |  0.18

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

Total # of neighbors = 276774
Ave neighs/atom = 138.38700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.509875316627, Press = -0.250777525482104
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -7877.4741   -7877.4741   -7952.1341   -7952.1341    288.94202    288.94202    23399.111    23399.111   -988.01783   -988.01783 
   70000    -7872.845    -7872.845   -7949.2501   -7949.2501    295.69591    295.69591    23419.068    23419.068   -2247.6677   -2247.6677 
Loop time of 11.5003 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.513 ns/day, 3.195 hours/ns, 86.954 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.299     | 11.299     | 11.299     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039938   | 0.039938   | 0.039938   |   0.0 |  0.35
Output  | 6.0088e-05 | 6.0088e-05 | 6.0088e-05 |   0.0 |  0.00
Modify  | 0.13998    | 0.13998    | 0.13998    |   0.0 |  1.22
Other   |            | 0.02105    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5463.00 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276664.0 ave      276664 max      276664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276664
Ave neighs/atom = 138.33200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.517160668238, Press = -0.233551810522083
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000    -7872.845    -7872.845   -7949.2501   -7949.2501    295.69591    295.69591    23419.068    23419.068   -2247.6677   -2247.6677 
   71000   -7877.0235   -7877.0235   -7952.1773   -7952.1773    290.85287    290.85287    23415.806    23415.806   -1980.8325   -1980.8325 
Loop time of 11.4977 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.515 ns/day, 3.194 hours/ns, 86.974 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.297     | 11.297     | 11.297     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039933   | 0.039933   | 0.039933   |   0.0 |  0.35
Output  | 5.635e-05  | 5.635e-05  | 5.635e-05  |   0.0 |  0.00
Modify  | 0.13927    | 0.13927    | 0.13927    |   0.0 |  1.21
Other   |            | 0.02097    |            |       |  0.18

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

Total # of neighbors = 276904
Ave neighs/atom = 138.45200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.52915054137, Press = 0.00506220719273812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -7877.0235   -7877.0235   -7952.1773   -7952.1773    290.85287    290.85287    23415.806    23415.806   -1980.8325   -1980.8325 
   72000   -7872.6644   -7872.6644   -7950.7213   -7950.7213    302.08818    302.08818    23426.557    23426.557    -2667.797    -2667.797 
Loop time of 11.6764 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.400 ns/day, 3.243 hours/ns, 85.643 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.469     | 11.469     | 11.469     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040798   | 0.040798   | 0.040798   |   0.0 |  0.35
Output  | 7.472e-05  | 7.472e-05  | 7.472e-05  |   0.0 |  0.00
Modify  | 0.14507    | 0.14507    | 0.14507    |   0.0 |  1.24
Other   |            | 0.02184    |            |       |  0.19

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

Total # of neighbors = 276442
Ave neighs/atom = 138.22100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.554735558327, Press = 0.5222366386182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -7872.6644   -7872.6644   -7950.7213   -7950.7213    302.08818    302.08818    23426.557    23426.557    -2667.797    -2667.797 
   73000    -7877.088    -7877.088   -7951.4661   -7951.4661    287.85078    287.85078    23432.046    23432.046   -3244.9569   -3244.9569 
Loop time of 11.4859 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.522 ns/day, 3.191 hours/ns, 87.063 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.286     | 11.286     | 11.286     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039962   | 0.039962   | 0.039962   |   0.0 |  0.35
Output  | 8.4301e-05 | 8.4301e-05 | 8.4301e-05 |   0.0 |  0.00
Modify  | 0.13916    | 0.13916    | 0.13916    |   0.0 |  1.21
Other   |            | 0.02095    |            |       |  0.18

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

Total # of neighbors = 276562
Ave neighs/atom = 138.28100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.584196425333, Press = 1.48089536666742
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000    -7877.088    -7877.088   -7951.4661   -7951.4661    287.85078    287.85078    23432.046    23432.046   -3244.9569   -3244.9569 
   74000   -7871.9515   -7871.9515   -7950.7143   -7950.7143    304.82003    304.82003     23404.32     23404.32   -1144.2547   -1144.2547 
Loop time of 11.4788 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.527 ns/day, 3.189 hours/ns, 87.117 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.278     | 11.278     | 11.278     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039956   | 0.039956   | 0.039956   |   0.0 |  0.35
Output  | 0.00020637 | 0.00020637 | 0.00020637 |   0.0 |  0.00
Modify  | 0.13969    | 0.13969    | 0.13969    |   0.0 |  1.22
Other   |            | 0.02113    |            |       |  0.18

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

Total # of neighbors = 276560
Ave neighs/atom = 138.28000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.588765728018, Press = 1.12627069710704
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -7871.9515   -7871.9515   -7950.7143   -7950.7143    304.82003    304.82003     23404.32     23404.32   -1144.2547   -1144.2547 
   75000   -7875.9717   -7875.9717   -7949.6448   -7949.6448    285.12242    285.12242    23380.127    23380.127    254.39231    254.39231 
Loop time of 11.8736 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.277 ns/day, 3.298 hours/ns, 84.220 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.658     | 11.658     | 11.658     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041673   | 0.041673   | 0.041673   |   0.0 |  0.35
Output  | 0.00010226 | 0.00010226 | 0.00010226 |   0.0 |  0.00
Modify  | 0.15081    | 0.15081    | 0.15081    |   0.0 |  1.27
Other   |            | 0.02294    |            |       |  0.19

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

Total # of neighbors = 276846
Ave neighs/atom = 138.42300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.604971501952, Press = 0.558646571973801
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -7875.9717   -7875.9717   -7949.6448   -7949.6448    285.12242    285.12242    23380.127    23380.127    254.39231    254.39231 
   76000     -7873.86     -7873.86   -7949.5193   -7949.5193    292.80917    292.80917     23371.78     23371.78    922.73711    922.73711 
Loop time of 11.8686 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.280 ns/day, 3.297 hours/ns, 84.256 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.651     | 11.651     | 11.651     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04248    | 0.04248    | 0.04248    |   0.0 |  0.36
Output  | 8.0818e-05 | 8.0818e-05 | 8.0818e-05 |   0.0 |  0.00
Modify  | 0.15117    | 0.15117    | 0.15117    |   0.0 |  1.27
Other   |            | 0.0234     |            |       |  0.20

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

Total # of neighbors = 277226
Ave neighs/atom = 138.61300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.626600615919, Press = 1.30239319055751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000     -7873.86     -7873.86   -7949.5193   -7949.5193    292.80917    292.80917     23371.78     23371.78    922.73711    922.73711 
   77000   -7874.8528   -7874.8528   -7950.3606   -7950.3606    292.22286    292.22286    23366.571    23366.571     1114.443     1114.443 
Loop time of 11.9712 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.217 ns/day, 3.325 hours/ns, 83.533 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.751     | 11.751     | 11.751     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042383   | 0.042383   | 0.042383   |   0.0 |  0.35
Output  | 7.9003e-05 | 7.9003e-05 | 7.9003e-05 |   0.0 |  0.00
Modify  | 0.15423    | 0.15423    | 0.15423    |   0.0 |  1.29
Other   |            | 0.02311    |            |       |  0.19

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

Total # of neighbors = 277328
Ave neighs/atom = 138.66400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.620026541662, Press = 1.05004338406659
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -7874.8528   -7874.8528   -7950.3606   -7950.3606    292.22286    292.22286    23366.571    23366.571     1114.443     1114.443 
   78000   -7876.5368   -7876.5368   -7951.5572   -7951.5572    290.33694    290.33694    23330.272    23330.272    3674.1435    3674.1435 
Loop time of 11.8283 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.305 ns/day, 3.286 hours/ns, 84.543 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.617     | 11.617     | 11.617     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041342   | 0.041342   | 0.041342   |   0.0 |  0.35
Output  | 6.0297e-05 | 6.0297e-05 | 6.0297e-05 |   0.0 |  0.00
Modify  | 0.14731    | 0.14731    | 0.14731    |   0.0 |  1.25
Other   |            | 0.02226    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5463.00 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277224.0 ave      277224 max      277224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277224
Ave neighs/atom = 138.61200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.625193110651, Press = 1.12588085690916
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -7876.5368   -7876.5368   -7951.5572   -7951.5572    290.33694    290.33694    23330.272    23330.272    3674.1435    3674.1435 
   79000   -7872.6096   -7872.6096   -7949.1002   -7949.1002    296.02626    296.02626    23328.242    23328.242    4124.2537    4124.2537 
Loop time of 11.5648 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.471 ns/day, 3.212 hours/ns, 86.469 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.36      | 11.36      | 11.36      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040211   | 0.040211   | 0.040211   |   0.0 |  0.35
Output  | 8.6783e-05 | 8.6783e-05 | 8.6783e-05 |   0.0 |  0.00
Modify  | 0.14251    | 0.14251    | 0.14251    |   0.0 |  1.23
Other   |            | 0.0218     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277644.0 ave      277644 max      277644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277644
Ave neighs/atom = 138.82200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.646041903859, Press = 0.926252273993867
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -7872.6096   -7872.6096   -7949.1002   -7949.1002    296.02626    296.02626    23328.242    23328.242    4124.2537    4124.2537 
   80000   -7876.4761   -7876.4761    -7952.115    -7952.115    292.73029    292.73029    23375.738    23375.738    673.30663    673.30663 
Loop time of 11.8779 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.274 ns/day, 3.299 hours/ns, 84.190 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.662     | 11.662     | 11.662     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041673   | 0.041673   | 0.041673   |   0.0 |  0.35
Output  | 6.7078e-05 | 6.7078e-05 | 6.7078e-05 |   0.0 |  0.00
Modify  | 0.15088    | 0.15088    | 0.15088    |   0.0 |  1.27
Other   |            | 0.02367    |            |       |  0.20

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

Total # of neighbors = 277704
Ave neighs/atom = 138.85200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.663500347567, Press = 0.427781249346327
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -7876.4761   -7876.4761    -7952.115    -7952.115    292.73029    292.73029    23375.738    23375.738    673.30663    673.30663 
   81000   -7875.2586   -7875.2586   -7950.0879   -7950.0879    289.59728    289.59728      23394.6      23394.6   -536.37491   -536.37491 
Loop time of 11.6035 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.446 ns/day, 3.223 hours/ns, 86.181 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.398     | 11.398     | 11.398     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040411   | 0.040411   | 0.040411   |   0.0 |  0.35
Output  | 8.9779e-05 | 8.9779e-05 | 8.9779e-05 |   0.0 |  0.00
Modify  | 0.14296    | 0.14296    | 0.14296    |   0.0 |  1.23
Other   |            | 0.02202    |            |       |  0.19

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

Total # of neighbors = 277100
Ave neighs/atom = 138.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 = 293.649195471149, Press = 0.544153299125357
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -7875.2586   -7875.2586   -7950.0879   -7950.0879    289.59728    289.59728      23394.6      23394.6   -536.37491   -536.37491 
   82000   -7876.1271   -7876.1271   -7951.9327   -7951.9327    293.37542    293.37542    23402.823    23402.823   -870.18936   -870.18936 
Loop time of 11.7334 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.364 ns/day, 3.259 hours/ns, 85.227 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.525     | 11.525     | 11.525     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040912   | 0.040912   | 0.040912   |   0.0 |  0.35
Output  | 6.213e-05  | 6.213e-05  | 6.213e-05  |   0.0 |  0.00
Modify  | 0.14546    | 0.14546    | 0.14546    |   0.0 |  1.24
Other   |            | 0.02222    |            |       |  0.19

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

Total # of neighbors = 276918
Ave neighs/atom = 138.45900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.637194003041, Press = 1.11278678481432
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -7876.1271   -7876.1271   -7951.9327   -7951.9327    293.37542    293.37542    23402.823    23402.823   -870.18936   -870.18936 
   83000   -7873.6738   -7873.6738   -7948.6892   -7948.6892    290.31729    290.31729    23393.731    23393.731   -433.18947   -433.18947 
Loop time of 11.6925 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.389 ns/day, 3.248 hours/ns, 85.525 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.485     | 11.485     | 11.485     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040797   | 0.040797   | 0.040797   |   0.0 |  0.35
Output  | 6.3016e-05 | 6.3016e-05 | 6.3016e-05 |   0.0 |  0.00
Modify  | 0.14475    | 0.14475    | 0.14475    |   0.0 |  1.24
Other   |            | 0.02209    |            |       |  0.19

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

Total # of neighbors = 276618
Ave neighs/atom = 138.30900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.646102364471, Press = 1.78599259439009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -7873.6738   -7873.6738   -7948.6892   -7948.6892    290.31729    290.31729    23393.731    23393.731   -433.18947   -433.18947 
   84000   -7873.1723   -7873.1723   -7950.4038   -7950.4038    298.89381    298.89381    23376.787    23376.787    637.34788    637.34788 
Loop time of 11.684 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.395 ns/day, 3.246 hours/ns, 85.587 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.477     | 11.477     | 11.477     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040636   | 0.040636   | 0.040636   |   0.0 |  0.35
Output  | 6.0486e-05 | 6.0486e-05 | 6.0486e-05 |   0.0 |  0.00
Modify  | 0.14464    | 0.14464    | 0.14464    |   0.0 |  1.24
Other   |            | 0.02195    |            |       |  0.19

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

Total # of neighbors = 277228
Ave neighs/atom = 138.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 = 293.648844045968, Press = 0.943388114699745
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -7873.1723   -7873.1723   -7950.4038   -7950.4038    298.89381    298.89381    23376.787    23376.787    637.34788    637.34788 
   85000   -7876.6961   -7876.6961   -7952.2106   -7952.2106    292.24897    292.24897    23371.622    23371.622     640.2332     640.2332 
Loop time of 11.7766 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.337 ns/day, 3.271 hours/ns, 84.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    | 11.566     | 11.566     | 11.566     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04121    | 0.04121    | 0.04121    |   0.0 |  0.35
Output  | 9.2026e-05 | 9.2026e-05 | 9.2026e-05 |   0.0 |  0.00
Modify  | 0.14701    | 0.14701    | 0.14701    |   0.0 |  1.25
Other   |            | 0.0221     |            |       |  0.19

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

Total # of neighbors = 277382
Ave neighs/atom = 138.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 = 293.674054337369, Press = 0.38095966704905
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -7876.6961   -7876.6961   -7952.2106   -7952.2106    292.24897    292.24897    23371.622    23371.622     640.2332     640.2332 
   86000   -7875.6595   -7875.6595   -7951.1383   -7951.1383    292.11075    292.11075    23366.828    23366.828    1147.7153    1147.7153 
Loop time of 11.8803 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.273 ns/day, 3.300 hours/ns, 84.173 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.668     | 11.668     | 11.668     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041315   | 0.041315   | 0.041315   |   0.0 |  0.35
Output  | 6.0298e-05 | 6.0298e-05 | 6.0298e-05 |   0.0 |  0.00
Modify  | 0.14843    | 0.14843    | 0.14843    |   0.0 |  1.25
Other   |            | 0.02234    |            |       |  0.19

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

Total # of neighbors = 277110
Ave neighs/atom = 138.55500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.660414496364, Press = 0.25217189387788
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -7875.6595   -7875.6595   -7951.1383   -7951.1383    292.11075    292.11075    23366.828    23366.828    1147.7153    1147.7153 
   87000   -7876.4434   -7876.4434   -7951.6441   -7951.6441    291.03477    291.03477    23349.549    23349.549    2211.8851    2211.8851 
Loop time of 11.4615 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.538 ns/day, 3.184 hours/ns, 87.249 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.263     | 11.263     | 11.263     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039513   | 0.039513   | 0.039513   |   0.0 |  0.34
Output  | 5.9565e-05 | 5.9565e-05 | 5.9565e-05 |   0.0 |  0.00
Modify  | 0.13788    | 0.13788    | 0.13788    |   0.0 |  1.20
Other   |            | 0.0206     |            |       |  0.18

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

Total # of neighbors = 277274
Ave neighs/atom = 138.63700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.656905058271, Press = 0.103683689503549
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -7876.4434   -7876.4434   -7951.6441   -7951.6441    291.03477    291.03477    23349.549    23349.549    2211.8851    2211.8851 
   88000    -7876.653    -7876.653   -7950.6232   -7950.6232    286.27233    286.27233    23341.613    23341.613    2843.4627    2843.4627 
Loop time of 11.4997 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.513 ns/day, 3.194 hours/ns, 86.958 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.298     | 11.298     | 11.298     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040054   | 0.040054   | 0.040054   |   0.0 |  0.35
Output  | 6.0008e-05 | 6.0008e-05 | 6.0008e-05 |   0.0 |  0.00
Modify  | 0.13993    | 0.13993    | 0.13993    |   0.0 |  1.22
Other   |            | 0.02152    |            |       |  0.19

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

Total # of neighbors = 277430
Ave neighs/atom = 138.71500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.61783063156, Press = -0.515420489433736
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000    -7876.653    -7876.653   -7950.6232   -7950.6232    286.27233    286.27233    23341.613    23341.613    2843.4627    2843.4627 
   89000   -7875.5657   -7875.5657   -7951.9789   -7951.9789    295.72708    295.72708    23368.552    23368.552     1588.875     1588.875 
Loop time of 11.4929 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.518 ns/day, 3.192 hours/ns, 87.011 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.293     | 11.293     | 11.293     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039915   | 0.039915   | 0.039915   |   0.0 |  0.35
Output  | 6.0623e-05 | 6.0623e-05 | 6.0623e-05 |   0.0 |  0.00
Modify  | 0.1391     | 0.1391     | 0.1391     |   0.0 |  1.21
Other   |            | 0.0211     |            |       |  0.18

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

Total # of neighbors = 277686
Ave neighs/atom = 138.84300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.618530804716, Press = -0.196780053847731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -7875.5657   -7875.5657   -7951.9789   -7951.9789    295.72708    295.72708    23368.552    23368.552     1588.875     1588.875 
   90000   -7871.3824   -7871.3824   -7949.9432   -7949.9432    304.03853    304.03853    23382.494    23382.494     445.3552     445.3552 
Loop time of 11.8491 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.292 ns/day, 3.291 hours/ns, 84.395 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.637     | 11.637     | 11.637     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041415   | 0.041415   | 0.041415   |   0.0 |  0.35
Output  | 8.1195e-05 | 8.1195e-05 | 8.1195e-05 |   0.0 |  0.00
Modify  | 0.14803    | 0.14803    | 0.14803    |   0.0 |  1.25
Other   |            | 0.02212    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5456.00 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276990.0 ave      276990 max      276990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276990
Ave neighs/atom = 138.49500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.628281304922, Press = -0.0440983905649404
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -7871.3824   -7871.3824   -7949.9432   -7949.9432    304.03853    304.03853    23382.494    23382.494     445.3552     445.3552 
   91000   -7877.4804   -7877.4804   -7952.0443   -7952.0443    288.57017    288.57017    23370.567    23370.567    791.50774    791.50774 
Loop time of 11.6949 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.388 ns/day, 3.249 hours/ns, 85.507 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.49      | 11.49      | 11.49      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040661   | 0.040661   | 0.040661   |   0.0 |  0.35
Output  | 6.2459e-05 | 6.2459e-05 | 6.2459e-05 |   0.0 |  0.00
Modify  | 0.14279    | 0.14279    | 0.14279    |   0.0 |  1.22
Other   |            | 0.02163    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5456.00 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277242.0 ave      277242 max      277242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277242
Ave neighs/atom = 138.62100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.633359883518, Press = 0.281011268144962
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -7877.4804   -7877.4804   -7952.0443   -7952.0443    288.57017    288.57017    23370.567    23370.567    791.50774    791.50774 
   92000   -7877.6056   -7877.6056   -7950.3452   -7950.3452    281.50966    281.50966    23379.266    23379.266    340.03327    340.03327 
Loop time of 11.7252 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.369 ns/day, 3.257 hours/ns, 85.286 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.518     | 11.518     | 11.518     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041052   | 0.041052   | 0.041052   |   0.0 |  0.35
Output  | 5.9989e-05 | 5.9989e-05 | 5.9989e-05 |   0.0 |  0.00
Modify  | 0.14453    | 0.14453    | 0.14453    |   0.0 |  1.23
Other   |            | 0.02205    |            |       |  0.19

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

Total # of neighbors = 277194
Ave neighs/atom = 138.59700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.6473834843, Press = 0.276178381898282
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -7877.6056   -7877.6056   -7950.3452   -7950.3452    281.50966    281.50966    23379.266    23379.266    340.03327    340.03327 
   93000   -7871.5839   -7871.5839   -7949.6161   -7949.6161    301.99278    301.99278    23372.852    23372.852    1065.9991    1065.9991 
Loop time of 11.6671 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.405 ns/day, 3.241 hours/ns, 85.711 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.46      | 11.46      | 11.46      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040784   | 0.040784   | 0.040784   |   0.0 |  0.35
Output  | 5.99e-05   | 5.99e-05   | 5.99e-05   |   0.0 |  0.00
Modify  | 0.14479    | 0.14479    | 0.14479    |   0.0 |  1.24
Other   |            | 0.02185    |            |       |  0.19

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

Total # of neighbors = 277226
Ave neighs/atom = 138.61300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.664146444584, Press = -0.0747023510557404
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -7871.5839   -7871.5839   -7949.6161   -7949.6161    301.99278    301.99278    23372.852    23372.852    1065.9991    1065.9991 
   94000   -7874.2491   -7874.2491   -7949.7789   -7949.7789    292.30823    292.30823    23375.075    23375.075    787.70402    787.70402 
Loop time of 11.5063 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.509 ns/day, 3.196 hours/ns, 86.909 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.304     | 11.304     | 11.304     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039792   | 0.039792   | 0.039792   |   0.0 |  0.35
Output  | 6.1054e-05 | 6.1054e-05 | 6.1054e-05 |   0.0 |  0.00
Modify  | 0.14071    | 0.14071    | 0.14071    |   0.0 |  1.22
Other   |            | 0.02145    |            |       |  0.19

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

Total # of neighbors = 277280
Ave neighs/atom = 138.64000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.665890855836, Press = -0.116159838225565
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -7874.2491   -7874.2491   -7949.7789   -7949.7789    292.30823    292.30823    23375.075    23375.075    787.70402    787.70402 
   95000    -7878.345    -7878.345   -7953.1978   -7953.1978    289.68844    289.68844     23372.38     23372.38    494.05614    494.05614 
Loop time of 12.0667 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.160 ns/day, 3.352 hours/ns, 82.873 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.846     | 11.846     | 11.846     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042724   | 0.042724   | 0.042724   |   0.0 |  0.35
Output  | 8.6121e-05 | 8.6121e-05 | 8.6121e-05 |   0.0 |  0.00
Modify  | 0.15463    | 0.15463    | 0.15463    |   0.0 |  1.28
Other   |            | 0.02293    |            |       |  0.19

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

Total # of neighbors = 277222
Ave neighs/atom = 138.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 = 293.651320244764, Press = -0.322255958051741
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000    -7878.345    -7878.345   -7953.1978   -7953.1978    289.68844    289.68844     23372.38     23372.38    494.05614    494.05614 
   96000   -7874.8773   -7874.8773   -7952.6466   -7952.6466    300.97531    300.97531    23384.931    23384.931   -8.3974992   -8.3974992 
Loop time of 11.5826 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.459 ns/day, 3.217 hours/ns, 86.337 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.378     | 11.378     | 11.378     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040634   | 0.040634   | 0.040634   |   0.0 |  0.35
Output  | 6.5266e-05 | 6.5266e-05 | 6.5266e-05 |   0.0 |  0.00
Modify  | 0.14254    | 0.14254    | 0.14254    |   0.0 |  1.23
Other   |            | 0.02147    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5463.00 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277164.0 ave      277164 max      277164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277164
Ave neighs/atom = 138.58200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.623423791698, Press = -0.592951068520243
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -7874.8773   -7874.8773   -7952.6466   -7952.6466    300.97531    300.97531    23384.931    23384.931   -8.3974992   -8.3974992 
   97000   -7878.2329   -7878.2329   -7952.2395   -7952.2395     286.4133     286.4133    23382.452    23382.452    53.899807    53.899807 
Loop time of 11.4707 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.532 ns/day, 3.186 hours/ns, 87.178 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.27      | 11.27      | 11.27      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039855   | 0.039855   | 0.039855   |   0.0 |  0.35
Output  | 7.0859e-05 | 7.0859e-05 | 7.0859e-05 |   0.0 |  0.00
Modify  | 0.13922    | 0.13922    | 0.13922    |   0.0 |  1.21
Other   |            | 0.02117    |            |       |  0.18

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

Total # of neighbors = 276954
Ave neighs/atom = 138.47700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.613065197385, Press = -0.538853247704199
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -7878.2329   -7878.2329   -7952.2395   -7952.2395     286.4133     286.4133    23382.452    23382.452    53.899807    53.899807 
   98000   -7874.3602   -7874.3602   -7950.8646   -7950.8646    296.07988    296.07988    23386.821    23386.821   -68.043548   -68.043548 
Loop time of 11.6656 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.406 ns/day, 3.240 hours/ns, 85.722 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.459     | 11.459     | 11.459     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040657   | 0.040657   | 0.040657   |   0.0 |  0.35
Output  | 6.4161e-05 | 6.4161e-05 | 6.4161e-05 |   0.0 |  0.00
Modify  | 0.14386    | 0.14386    | 0.14386    |   0.0 |  1.23
Other   |            | 0.02179    |            |       |  0.19

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

Total # of neighbors = 277242
Ave neighs/atom = 138.62100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.628198118997, Press = 0.0329284060084854
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -7874.3602   -7874.3602   -7950.8646   -7950.8646    296.07988    296.07988    23386.821    23386.821   -68.043548   -68.043548 
   99000   -7872.1938   -7872.1938   -7952.0351   -7952.0351     308.9943     308.9943    23393.955    23393.955    -405.8876    -405.8876 
Loop time of 11.6813 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.396 ns/day, 3.245 hours/ns, 85.607 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.474     | 11.474     | 11.474     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040782   | 0.040782   | 0.040782   |   0.0 |  0.35
Output  | 5.9476e-05 | 5.9476e-05 | 5.9476e-05 |   0.0 |  0.00
Modify  | 0.14434    | 0.14434    | 0.14434    |   0.0 |  1.24
Other   |            | 0.02185    |            |       |  0.19

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

Total # of neighbors = 276932
Ave neighs/atom = 138.46600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.629620731971, Press = 0.17856487951951
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -7872.1938   -7872.1938   -7952.0351   -7952.0351     308.9943     308.9943    23393.955    23393.955    -405.8876    -405.8876 
  100000   -7877.2899   -7877.2899   -7952.9518   -7952.9518    292.81949    292.81949     23373.32     23373.32    599.56022    599.56022 
Loop time of 11.7084 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.379 ns/day, 3.252 hours/ns, 85.408 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.5       | 11.5       | 11.5       |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040767   | 0.040767   | 0.040767   |   0.0 |  0.35
Output  | 9.5287e-05 | 9.5287e-05 | 9.5287e-05 |   0.0 |  0.00
Modify  | 0.14536    | 0.14536    | 0.14536    |   0.0 |  1.24
Other   |            | 0.02181    |            |       |  0.19

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

Total # of neighbors = 276908
Ave neighs/atom = 138.45400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.647466825973, Press = 0.148472164172046
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -7877.2899   -7877.2899   -7952.9518   -7952.9518    292.81949    292.81949     23373.32     23373.32    599.56022    599.56022 
  101000   -7873.8467   -7873.8467   -7950.5302   -7950.5302    296.77324    296.77324    23371.611    23371.611     628.0589     628.0589 
Loop time of 11.5631 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.472 ns/day, 3.212 hours/ns, 86.482 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.357     | 11.357     | 11.357     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040363   | 0.040363   | 0.040363   |   0.0 |  0.35
Output  | 6.2572e-05 | 6.2572e-05 | 6.2572e-05 |   0.0 |  0.00
Modify  | 0.14255    | 0.14255    | 0.14255    |   0.0 |  1.23
Other   |            | 0.02273    |            |       |  0.20

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

Total # of neighbors = 277198
Ave neighs/atom = 138.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 = 293.661317706597, Press = -0.294844807417831
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -7873.8467   -7873.8467   -7950.5302   -7950.5302    296.77324    296.77324    23371.611    23371.611     628.0589     628.0589 
  102000   -7875.8411   -7875.8411   -7950.6757   -7950.6757    289.61739    289.61739    23379.212    23379.212    194.26942    194.26942 
Loop time of 11.8102 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.316 ns/day, 3.281 hours/ns, 84.672 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.599     | 11.599     | 11.599     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041391   | 0.041391   | 0.041391   |   0.0 |  0.35
Output  | 6.0319e-05 | 6.0319e-05 | 6.0319e-05 |   0.0 |  0.00
Modify  | 0.14766    | 0.14766    | 0.14766    |   0.0 |  1.25
Other   |            | 0.02241    |            |       |  0.19

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

Total # of neighbors = 277226
Ave neighs/atom = 138.61300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.673525017938, Press = -1.09615912825832
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -7875.8411   -7875.8411   -7950.6757   -7950.6757    289.61739    289.61739    23379.212    23379.212    194.26942    194.26942 
  103000     -7875.94     -7875.94   -7951.5593   -7951.5593    292.65444    292.65444    23394.765    23394.765   -624.00641   -624.00641 
Loop time of 11.7091 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.379 ns/day, 3.253 hours/ns, 85.403 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.5       | 11.5       | 11.5       |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040908   | 0.040908   | 0.040908   |   0.0 |  0.35
Output  | 6.1951e-05 | 6.1951e-05 | 6.1951e-05 |   0.0 |  0.00
Modify  | 0.14559    | 0.14559    | 0.14559    |   0.0 |  1.24
Other   |            | 0.02215    |            |       |  0.19

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

Total # of neighbors = 277478
Ave neighs/atom = 138.73900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.661142071951, Press = -0.524614403253788
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000     -7875.94     -7875.94   -7951.5593   -7951.5593    292.65444    292.65444    23394.765    23394.765   -624.00641   -624.00641 
  104000   -7873.3372   -7873.3372   -7949.4936   -7949.4936    294.73311    294.73311    23412.757    23412.757   -1763.9141   -1763.9141 
Loop time of 11.5537 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.478 ns/day, 3.209 hours/ns, 86.552 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.35      | 11.35      | 11.35      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040354   | 0.040354   | 0.040354   |   0.0 |  0.35
Output  | 5.9366e-05 | 5.9366e-05 | 5.9366e-05 |   0.0 |  0.00
Modify  | 0.14191    | 0.14191    | 0.14191    |   0.0 |  1.23
Other   |            | 0.02142    |            |       |  0.19

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

Total # of neighbors = 276936
Ave neighs/atom = 138.46800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.656289640634, Press = -0.342043016938951
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -7873.3372   -7873.3372   -7949.4936   -7949.4936    294.73311    294.73311    23412.757    23412.757   -1763.9141   -1763.9141 
  105000   -7881.8292   -7881.8292   -7954.7662   -7954.7662    282.27341    282.27341    23394.532    23394.532   -1042.7973   -1042.7973 
Loop time of 11.6418 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.422 ns/day, 3.234 hours/ns, 85.897 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.435     | 11.435     | 11.435     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040703   | 0.040703   | 0.040703   |   0.0 |  0.35
Output  | 8.2789e-05 | 8.2789e-05 | 8.2789e-05 |   0.0 |  0.00
Modify  | 0.14388    | 0.14388    | 0.14388    |   0.0 |  1.24
Other   |            | 0.02164    |            |       |  0.19

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

Total # of neighbors = 276986
Ave neighs/atom = 138.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 = 293.645878079807, Press = -0.196322089706386
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -7881.8292   -7881.8292   -7954.7662   -7954.7662    282.27341    282.27341    23394.532    23394.532   -1042.7973   -1042.7973 
  106000    -7875.517    -7875.517   -7951.4959   -7951.4959    294.04609    294.04609    23398.079    23398.079    -1276.291    -1276.291 
Loop time of 11.5023 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.512 ns/day, 3.195 hours/ns, 86.939 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.301     | 11.301     | 11.301     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039997   | 0.039997   | 0.039997   |   0.0 |  0.35
Output  | 7.3056e-05 | 7.3056e-05 | 7.3056e-05 |   0.0 |  0.00
Modify  | 0.14001    | 0.14001    | 0.14001    |   0.0 |  1.22
Other   |            | 0.02131    |            |       |  0.19

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

Total # of neighbors = 276696
Ave neighs/atom = 138.34800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.615654752983, Press = 0.0226465412347395
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000    -7875.517    -7875.517   -7951.4959   -7951.4959    294.04609    294.04609    23398.079    23398.079    -1276.291    -1276.291 
  107000   -7876.1904   -7876.1904   -7952.5677   -7952.5677    295.58829    295.58829    23403.991    23403.991   -1481.3116   -1481.3116 
Loop time of 11.8295 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.304 ns/day, 3.286 hours/ns, 84.535 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.618     | 11.618     | 11.618     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041589   | 0.041589   | 0.041589   |   0.0 |  0.35
Output  | 6.3133e-05 | 6.3133e-05 | 6.3133e-05 |   0.0 |  0.00
Modify  | 0.14785    | 0.14785    | 0.14785    |   0.0 |  1.25
Other   |            | 0.02202    |            |       |  0.19

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

Total # of neighbors = 276960
Ave neighs/atom = 138.48000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.615080795553, Press = -0.0354847189367313
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -7876.1904   -7876.1904   -7952.5677   -7952.5677    295.58829    295.58829    23403.991    23403.991   -1481.3116   -1481.3116 
  108000   -7872.9481   -7872.9481    -7948.412    -7948.412    292.05319    292.05319    23413.271    23413.271   -1932.2036   -1932.2036 
Loop time of 11.5978 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.450 ns/day, 3.222 hours/ns, 86.224 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.393     | 11.393     | 11.393     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040383   | 0.040383   | 0.040383   |   0.0 |  0.35
Output  | 6.5246e-05 | 6.5246e-05 | 6.5246e-05 |   0.0 |  0.00
Modify  | 0.14265    | 0.14265    | 0.14265    |   0.0 |  1.23
Other   |            | 0.02183    |            |       |  0.19

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

Total # of neighbors = 276584
Ave neighs/atom = 138.29200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.620488811819, Press = 0.0766447580165843
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -7872.9481   -7872.9481    -7948.412    -7948.412    292.05319    292.05319    23413.271    23413.271   -1932.2036   -1932.2036 
  109000   -7877.3598   -7877.3598   -7954.4481   -7954.4481    298.33967    298.33967     23422.08     23422.08   -3051.8833   -3051.8833 
Loop time of 11.6424 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.421 ns/day, 3.234 hours/ns, 85.893 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.436     | 11.436     | 11.436     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040476   | 0.040476   | 0.040476   |   0.0 |  0.35
Output  | 6.0544e-05 | 6.0544e-05 | 6.0544e-05 |   0.0 |  0.00
Modify  | 0.14412    | 0.14412    | 0.14412    |   0.0 |  1.24
Other   |            | 0.02166    |            |       |  0.19

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

Total # of neighbors = 277100
Ave neighs/atom = 138.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 = 293.620572068242, Press = -0.0360144073783855
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -7877.3598   -7877.3598   -7954.4481   -7954.4481    298.33967    298.33967     23422.08     23422.08   -3051.8833   -3051.8833 
  110000   -7876.1215   -7876.1215   -7951.2045   -7951.2045    290.57883    290.57883    23427.525    23427.525   -2904.2448   -2904.2448 
Loop time of 11.7147 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.375 ns/day, 3.254 hours/ns, 85.363 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.506     | 11.506     | 11.506     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040953   | 0.040953   | 0.040953   |   0.0 |  0.35
Output  | 8.9076e-05 | 8.9076e-05 | 8.9076e-05 |   0.0 |  0.00
Modify  | 0.1461     | 0.1461     | 0.1461     |   0.0 |  1.25
Other   |            | 0.02183    |            |       |  0.19

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

Total # of neighbors = 276430
Ave neighs/atom = 138.21500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.629139899237, Press = 0.0959939822508638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -7876.1215   -7876.1215   -7951.2045   -7951.2045    290.57883    290.57883    23427.525    23427.525   -2904.2448   -2904.2448 
  111000   -7875.7425   -7875.7425   -7952.6873   -7952.6873    297.78424    297.78424    23428.758    23428.758   -3213.3357   -3213.3357 
Loop time of 11.5019 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.512 ns/day, 3.195 hours/ns, 86.942 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.3       | 11.3       | 11.3       |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040038   | 0.040038   | 0.040038   |   0.0 |  0.35
Output  | 8.0494e-05 | 8.0494e-05 | 8.0494e-05 |   0.0 |  0.00
Modify  | 0.14035    | 0.14035    | 0.14035    |   0.0 |  1.22
Other   |            | 0.02167    |            |       |  0.19

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

Total # of neighbors = 276694
Ave neighs/atom = 138.34700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.647559810698, Press = 0.432519593146737
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -7875.7425   -7875.7425   -7952.6873   -7952.6873    297.78424    297.78424    23428.758    23428.758   -3213.3357   -3213.3357 
  112000   -7878.0294   -7878.0294   -7951.7543   -7951.7543    285.32273    285.32273     23398.52     23398.52   -1388.0188   -1388.0188 
Loop time of 11.5968 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.450 ns/day, 3.221 hours/ns, 86.231 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.393     | 11.393     | 11.393     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040412   | 0.040412   | 0.040412   |   0.0 |  0.35
Output  | 8.0165e-05 | 8.0165e-05 | 8.0165e-05 |   0.0 |  0.00
Modify  | 0.14229    | 0.14229    | 0.14229    |   0.0 |  1.23
Other   |            | 0.02133    |            |       |  0.18

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

Total # of neighbors = 276572
Ave neighs/atom = 138.28600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.64439919957, Press = 0.473659700762477
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -7878.0294   -7878.0294   -7951.7543   -7951.7543    285.32273    285.32273     23398.52     23398.52   -1388.0188   -1388.0188 
  113000   -7874.3872   -7874.3872   -7950.2616   -7950.2616    293.64171    293.64171    23401.038    23401.038     -1227.29     -1227.29 
Loop time of 11.929 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.243 ns/day, 3.314 hours/ns, 83.829 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.712     | 11.712     | 11.712     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04204    | 0.04204    | 0.04204    |   0.0 |  0.35
Output  | 7.9017e-05 | 7.9017e-05 | 7.9017e-05 |   0.0 |  0.00
Modify  | 0.15212    | 0.15212    | 0.15212    |   0.0 |  1.28
Other   |            | 0.02296    |            |       |  0.19

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

Total # of neighbors = 276912
Ave neighs/atom = 138.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 = 293.632601558652, Press = 0.210277325679645
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -7874.3872   -7874.3872   -7950.2616   -7950.2616    293.64171    293.64171    23401.038    23401.038     -1227.29     -1227.29 
  114000   -7877.2756   -7877.2756   -7951.1599   -7951.1599    285.93991    285.93991    23391.025    23391.025   -525.25945   -525.25945 
Loop time of 11.7543 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.350 ns/day, 3.265 hours/ns, 85.075 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.545     | 11.545     | 11.545     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041164   | 0.041164   | 0.041164   |   0.0 |  0.35
Output  | 8.3766e-05 | 8.3766e-05 | 8.3766e-05 |   0.0 |  0.00
Modify  | 0.14638    | 0.14638    | 0.14638    |   0.0 |  1.25
Other   |            | 0.02196    |            |       |  0.19

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

Total # of neighbors = 277274
Ave neighs/atom = 138.63700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.598374667984, Press = 0.0962572277069758
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000   -7877.2756   -7877.2756   -7951.1599   -7951.1599    285.93991    285.93991    23391.025    23391.025   -525.25945   -525.25945 
  115000   -7875.4678   -7875.4678   -7951.4089   -7951.4089    293.89958    293.89958     23398.42     23398.42   -1195.6022   -1195.6022 
Loop time of 11.7927 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.327 ns/day, 3.276 hours/ns, 84.798 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.581     | 11.581     | 11.581     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041324   | 0.041324   | 0.041324   |   0.0 |  0.35
Output  | 5.9722e-05 | 5.9722e-05 | 5.9722e-05 |   0.0 |  0.00
Modify  | 0.14773    | 0.14773    | 0.14773    |   0.0 |  1.25
Other   |            | 0.02246    |            |       |  0.19

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

Total # of neighbors = 277036
Ave neighs/atom = 138.51800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.588637699933, Press = 0.240039926809926
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -7875.4678   -7875.4678   -7951.4089   -7951.4089    293.89958    293.89958     23398.42     23398.42   -1195.6022   -1195.6022 
  116000   -7874.4982   -7874.4982    -7949.378    -7949.378    289.79256    289.79256    23425.762    23425.762   -2954.4443   -2954.4443 
Loop time of 11.6996 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.385 ns/day, 3.250 hours/ns, 85.473 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.492     | 11.492     | 11.492     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040818   | 0.040818   | 0.040818   |   0.0 |  0.35
Output  | 7.8908e-05 | 7.8908e-05 | 7.8908e-05 |   0.0 |  0.00
Modify  | 0.14515    | 0.14515    | 0.14515    |   0.0 |  1.24
Other   |            | 0.02166    |            |       |  0.19

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

Total # of neighbors = 277012
Ave neighs/atom = 138.50600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.585930417846, Press = 0.9337319570661
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -7874.4982   -7874.4982    -7949.378    -7949.378    289.79256    289.79256    23425.762    23425.762   -2954.4443   -2954.4443 
  117000   -7877.4721   -7877.4721    -7951.498    -7951.498    286.48792    286.48792    23394.847    23394.847   -1074.2361   -1074.2361 
Loop time of 11.7021 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.383 ns/day, 3.251 hours/ns, 85.454 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.494     | 11.494     | 11.494     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040949   | 0.040949   | 0.040949   |   0.0 |  0.35
Output  | 6.0666e-05 | 6.0666e-05 | 6.0666e-05 |   0.0 |  0.00
Modify  | 0.14556    | 0.14556    | 0.14556    |   0.0 |  1.24
Other   |            | 0.02169    |            |       |  0.19

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

Total # of neighbors = 276864
Ave neighs/atom = 138.43200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.575641520721, Press = 0.70661860169275
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -7877.4721   -7877.4721    -7951.498    -7951.498    286.48792    286.48792    23394.847    23394.847   -1074.2361   -1074.2361 
  118000   -7873.8423   -7873.8423   -7950.9499   -7950.9499    298.41449    298.41449    23364.645    23364.645    1553.6185    1553.6185 
Loop time of 11.5817 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.460 ns/day, 3.217 hours/ns, 86.343 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.377     | 11.377     | 11.377     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040509   | 0.040509   | 0.040509   |   0.0 |  0.35
Output  | 5.8379e-05 | 5.8379e-05 | 5.8379e-05 |   0.0 |  0.00
Modify  | 0.14248    | 0.14248    | 0.14248    |   0.0 |  1.23
Other   |            | 0.02168    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5465.00 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277190.0 ave      277190 max      277190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277190
Ave neighs/atom = 138.59500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.570874870891, Press = 0.807514901505361
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -7873.8423   -7873.8423   -7950.9499   -7950.9499    298.41449    298.41449    23364.645    23364.645    1553.6185    1553.6185 
  119000   -7876.1495   -7876.1495   -7949.1227   -7949.1227    282.41389    282.41389    23367.342    23367.342    1369.7413    1369.7413 
Loop time of 11.6965 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.387 ns/day, 3.249 hours/ns, 85.495 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.488     | 11.488     | 11.488     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041099   | 0.041099   | 0.041099   |   0.0 |  0.35
Output  | 6.0412e-05 | 6.0412e-05 | 6.0412e-05 |   0.0 |  0.00
Modify  | 0.14508    | 0.14508    | 0.14508    |   0.0 |  1.24
Other   |            | 0.0222     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5463.00 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277258.0 ave      277258 max      277258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277258
Ave neighs/atom = 138.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 = 293.572448787421, Press = 0.559488807864496
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000   -7876.1495   -7876.1495   -7949.1227   -7949.1227    282.41389    282.41389    23367.342    23367.342    1369.7413    1369.7413 
  120000   -7875.8251   -7875.8251    -7950.546    -7950.546    289.17746    289.17746    23372.872    23372.872    708.13468    708.13468 
Loop time of 11.5492 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.481 ns/day, 3.208 hours/ns, 86.586 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.345     | 11.345     | 11.345     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040373   | 0.040373   | 0.040373   |   0.0 |  0.35
Output  | 7.8012e-05 | 7.8012e-05 | 7.8012e-05 |   0.0 |  0.00
Modify  | 0.14191    | 0.14191    | 0.14191    |   0.0 |  1.23
Other   |            | 0.02155    |            |       |  0.19

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

Total # of neighbors = 277340
Ave neighs/atom = 138.67000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.591583183401, Press = 0.289057994933911
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -7875.8251   -7875.8251    -7950.546    -7950.546    289.17746    289.17746    23372.872    23372.872    708.13468    708.13468 
  121000   -7872.8376   -7872.8376   -7950.4516   -7950.4516    300.37428    300.37428    23371.788    23371.788    1037.8141    1037.8141 
Loop time of 11.5097 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.507 ns/day, 3.197 hours/ns, 86.883 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.308     | 11.308     | 11.308     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04009    | 0.04009    | 0.04009    |   0.0 |  0.35
Output  | 5.8216e-05 | 5.8216e-05 | 5.8216e-05 |   0.0 |  0.00
Modify  | 0.14022    | 0.14022    | 0.14022    |   0.0 |  1.22
Other   |            | 0.02119    |            |       |  0.18

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

Total # of neighbors = 277162
Ave neighs/atom = 138.58100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.595109141128, Press = 0.110688304016804
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000   -7872.8376   -7872.8376   -7950.4516   -7950.4516    300.37428    300.37428    23371.788    23371.788    1037.8141    1037.8141 
  122000   -7875.8987   -7875.8987   -7950.2144   -7950.2144    287.60948    287.60948    23370.237    23370.237    932.75894    932.75894 
Loop time of 11.5701 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.467 ns/day, 3.214 hours/ns, 86.429 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.367     | 11.367     | 11.367     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040268   | 0.040268   | 0.040268   |   0.0 |  0.35
Output  | 5.9455e-05 | 5.9455e-05 | 5.9455e-05 |   0.0 |  0.00
Modify  | 0.14187    | 0.14187    | 0.14187    |   0.0 |  1.23
Other   |            | 0.02134    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5465.00 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277124.0 ave      277124 max      277124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277124
Ave neighs/atom = 138.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 = 293.592387985442, Press = 0.246884604786214
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  122000   -7875.8987   -7875.8987   -7950.2144   -7950.2144    287.60948    287.60948    23370.237    23370.237    932.75894    932.75894 
  123000   -7878.4242   -7878.4242   -7951.4307   -7951.4307    282.54289    282.54289    23367.804    23367.804    1124.6293    1124.6293 
Loop time of 11.5654 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.471 ns/day, 3.213 hours/ns, 86.465 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.363     | 11.363     | 11.363     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04017    | 0.04017    | 0.04017    |   0.0 |  0.35
Output  | 6.1492e-05 | 6.1492e-05 | 6.1492e-05 |   0.0 |  0.00
Modify  | 0.14137    | 0.14137    | 0.14137    |   0.0 |  1.22
Other   |            | 0.02114    |            |       |  0.18

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

Total # of neighbors = 277322
Ave neighs/atom = 138.66100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.589632505527, Press = 0.217692905105883
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  123000   -7878.4242   -7878.4242   -7951.4307   -7951.4307    282.54289    282.54289    23367.804    23367.804    1124.6293    1124.6293 
  124000   -7875.4943   -7875.4943   -7950.7321   -7950.7321    291.17804    291.17804    23377.667    23377.667    74.226421    74.226421 
Loop time of 11.4998 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.513 ns/day, 3.194 hours/ns, 86.958 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.299     | 11.299     | 11.299     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039867   | 0.039867   | 0.039867   |   0.0 |  0.35
Output  | 0.00018925 | 0.00018925 | 0.00018925 |   0.0 |  0.00
Modify  | 0.13926    | 0.13926    | 0.13926    |   0.0 |  1.21
Other   |            | 0.02099    |            |       |  0.18

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

Total # of neighbors = 277140
Ave neighs/atom = 138.57000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.583181290952, Press = 0.388542096751401
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  124000   -7875.4943   -7875.4943   -7950.7321   -7950.7321    291.17804    291.17804    23377.667    23377.667    74.226421    74.226421 
  125000   -7874.9195   -7874.9195   -7953.3027   -7953.3027    303.35077    303.35077    23368.029    23368.029    746.38707    746.38707 
Loop time of 11.6425 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.421 ns/day, 3.234 hours/ns, 85.892 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.437     | 11.437     | 11.437     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04056    | 0.04056    | 0.04056    |   0.0 |  0.35
Output  | 7.9135e-05 | 7.9135e-05 | 7.9135e-05 |   0.0 |  0.00
Modify  | 0.14334    | 0.14334    | 0.14334    |   0.0 |  1.23
Other   |            | 0.02173    |            |       |  0.19

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

Total # of neighbors = 277372
Ave neighs/atom = 138.68600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.581522040177, Press = 0.129360525658398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  125000   -7874.9195   -7874.9195   -7953.3027   -7953.3027    303.35077    303.35077    23368.029    23368.029    746.38707    746.38707 
  126000    -7880.053    -7880.053    -7955.348    -7955.348    291.39925    291.39925    23341.499    23341.499    2696.9214    2696.9214 
Loop time of 11.5088 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.507 ns/day, 3.197 hours/ns, 86.890 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.307     | 11.307     | 11.307     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039956   | 0.039956   | 0.039956   |   0.0 |  0.35
Output  | 8.5611e-05 | 8.5611e-05 | 8.5611e-05 |   0.0 |  0.00
Modify  | 0.14028    | 0.14028    | 0.14028    |   0.0 |  1.22
Other   |            | 0.02123    |            |       |  0.18

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

Total # of neighbors = 277200
Ave neighs/atom = 138.60000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.568450388047, Press = 0.0851506008198922
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  126000    -7880.053    -7880.053    -7955.348    -7955.348    291.39925    291.39925    23341.499    23341.499    2696.9214    2696.9214 
  127000   -7873.8688   -7873.8688   -7950.9332   -7950.9332    298.24715    298.24715    23340.944    23340.944    2972.0233    2972.0233 
Loop time of 11.6529 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.414 ns/day, 3.237 hours/ns, 85.816 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.446     | 11.446     | 11.446     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040601   | 0.040601   | 0.040601   |   0.0 |  0.35
Output  | 0.00070506 | 0.00070506 | 0.00070506 |   0.0 |  0.01
Modify  | 0.14377    | 0.14377    | 0.14377    |   0.0 |  1.23
Other   |            | 0.02179    |            |       |  0.19

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

Total # of neighbors = 277282
Ave neighs/atom = 138.64100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.556778907712, Press = -0.200585554718996
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  127000   -7873.8688   -7873.8688   -7950.9332   -7950.9332    298.24715    298.24715    23340.944    23340.944    2972.0233    2972.0233 
  128000   -7874.6539   -7874.6539   -7951.1896   -7951.1896    296.20113    296.20113    23345.621    23345.621    2810.4463    2810.4463 
Loop time of 11.745 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.356 ns/day, 3.263 hours/ns, 85.142 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.534     | 11.534     | 11.534     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041272   | 0.041272   | 0.041272   |   0.0 |  0.35
Output  | 0.00019131 | 0.00019131 | 0.00019131 |   0.0 |  0.00
Modify  | 0.14654    | 0.14654    | 0.14654    |   0.0 |  1.25
Other   |            | 0.0227     |            |       |  0.19

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

Total # of neighbors = 277758
Ave neighs/atom = 138.87900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.542726210013, Press = -0.189359926012029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  128000   -7874.6539   -7874.6539   -7951.1896   -7951.1896    296.20113    296.20113    23345.621    23345.621    2810.4463    2810.4463 
  129000   -7872.2311   -7872.2311   -7950.3256   -7950.3256    302.23368    302.23368    23382.678    23382.678    298.13684    298.13684 
Loop time of 11.7318 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.365 ns/day, 3.259 hours/ns, 85.238 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.523     | 11.523     | 11.523     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041093   | 0.041093   | 0.041093   |   0.0 |  0.35
Output  | 0.00010825 | 0.00010825 | 0.00010825 |   0.0 |  0.00
Modify  | 0.14594    | 0.14594    | 0.14594    |   0.0 |  1.24
Other   |            | 0.02202    |            |       |  0.19

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

Total # of neighbors = 277560
Ave neighs/atom = 138.78000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.531230742527, Press = -0.137979363498521
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  129000   -7872.2311   -7872.2311   -7950.3256   -7950.3256    302.23368    302.23368    23382.678    23382.678    298.13684    298.13684 
  130000   -7876.8656   -7876.8656     -7949.97     -7949.97    282.92184    282.92184    23383.606    23383.606    28.274843    28.274843 
Loop time of 11.5589 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.475 ns/day, 3.211 hours/ns, 86.514 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.355     | 11.355     | 11.355     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040368   | 0.040368   | 0.040368   |   0.0 |  0.35
Output  | 0.00020008 | 0.00020008 | 0.00020008 |   0.0 |  0.00
Modify  | 0.1416     | 0.1416     | 0.1416     |   0.0 |  1.23
Other   |            | 0.02137    |            |       |  0.18

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

Total # of neighbors = 276958
Ave neighs/atom = 138.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 = 293.543485691888, Press = 0.0807276157867489
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  130000   -7876.8656   -7876.8656     -7949.97     -7949.97    282.92184    282.92184    23383.606    23383.606    28.274843    28.274843 
  131000   -7872.1154   -7872.1154   -7950.9633   -7950.9633    305.14941    305.14941    23376.121    23376.121     731.5136     731.5136 
Loop time of 11.5345 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.491 ns/day, 3.204 hours/ns, 86.696 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.33      | 11.33      | 11.33      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040056   | 0.040056   | 0.040056   |   0.0 |  0.35
Output  | 8.5836e-05 | 8.5836e-05 | 8.5836e-05 |   0.0 |  0.00
Modify  | 0.1417     | 0.1417     | 0.1417     |   0.0 |  1.23
Other   |            | 0.02227    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5465.00 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277312.0 ave      277312 max      277312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277312
Ave neighs/atom = 138.65600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.556859546051, Press = 0.114964533957827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  131000   -7872.1154   -7872.1154   -7950.9633   -7950.9633    305.14941    305.14941    23376.121    23376.121     731.5136     731.5136 
  132000   -7877.0222   -7877.0222   -7951.6707   -7951.6707    288.89732    288.89732    23356.337    23356.337    1922.4565    1922.4565 
Loop time of 11.6262 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.432 ns/day, 3.229 hours/ns, 86.013 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.418     | 11.418     | 11.418     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040804   | 0.040804   | 0.040804   |   0.0 |  0.35
Output  | 8.8564e-05 | 8.8564e-05 | 8.8564e-05 |   0.0 |  0.00
Modify  | 0.1443     | 0.1443     | 0.1443     |   0.0 |  1.24
Other   |            | 0.02252    |            |       |  0.19

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

Total # of neighbors = 277194
Ave neighs/atom = 138.59700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.563824418051, Press = 0.311540953508918
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  132000   -7877.0222   -7877.0222   -7951.6707   -7951.6707    288.89732    288.89732    23356.337    23356.337    1922.4565    1922.4565 
  133000   -7873.8622   -7873.8622    -7949.296    -7949.296    291.93664    291.93664    23349.001    23349.001    2311.3993    2311.3993 
Loop time of 11.5896 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.455 ns/day, 3.219 hours/ns, 86.284 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    | 11.385     | 11.385     | 11.385     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040402   | 0.040402   | 0.040402   |   0.0 |  0.35
Output  | 9.1245e-05 | 9.1245e-05 | 9.1245e-05 |   0.0 |  0.00
Modify  | 0.14274    | 0.14274    | 0.14274    |   0.0 |  1.23
Other   |            | 0.02183    |            |       |  0.19

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

Total # of neighbors = 277446
Ave neighs/atom = 138.72300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.57298529036, Press = 0.311155148735453
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  133000   -7873.8622   -7873.8622    -7949.296    -7949.296    291.93664    291.93664    23349.001    23349.001    2311.3993    2311.3993 
  134000   -7875.3433   -7875.3433   -7951.0527   -7951.0527    293.00352    293.00352    23347.554    23347.554    2362.1622    2362.1622 
Loop time of 11.6964 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.387 ns/day, 3.249 hours/ns, 85.496 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.49      | 11.49      | 11.49      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040776   | 0.040776   | 0.040776   |   0.0 |  0.35
Output  | 7.9496e-05 | 7.9496e-05 | 7.9496e-05 |   0.0 |  0.00
Modify  | 0.14443    | 0.14443    | 0.14443    |   0.0 |  1.23
Other   |            | 0.02157    |            |       |  0.18

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

Total # of neighbors = 277582
Ave neighs/atom = 138.79100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.56055366644, Press = 0.013427573951575
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  134000   -7875.3433   -7875.3433   -7951.0527   -7951.0527    293.00352    293.00352    23347.554    23347.554    2362.1622    2362.1622 
  135000   -7875.6836   -7875.6836   -7951.8613   -7951.8613    294.81566    294.81566    23367.819    23367.819    833.86527    833.86527 
Loop time of 11.5921 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.453 ns/day, 3.220 hours/ns, 86.266 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.388     | 11.388     | 11.388     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040346   | 0.040346   | 0.040346   |   0.0 |  0.35
Output  | 7.9409e-05 | 7.9409e-05 | 7.9409e-05 |   0.0 |  0.00
Modify  | 0.14224    | 0.14224    | 0.14224    |   0.0 |  1.23
Other   |            | 0.02144    |            |       |  0.18

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

Total # of neighbors = 277374
Ave neighs/atom = 138.68700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.560128253187, Press = -0.411724515230126
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  135000   -7875.6836   -7875.6836   -7951.8613   -7951.8613    294.81566    294.81566    23367.819    23367.819    833.86527    833.86527 
  136000   -7873.6171   -7873.6171   -7949.3649   -7949.3649    293.15171    293.15171    23375.591    23375.591     801.7144     801.7144 
Loop time of 11.5366 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.489 ns/day, 3.205 hours/ns, 86.681 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.333     | 11.333     | 11.333     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040185   | 0.040185   | 0.040185   |   0.0 |  0.35
Output  | 8.7941e-05 | 8.7941e-05 | 8.7941e-05 |   0.0 |  0.00
Modify  | 0.14109    | 0.14109    | 0.14109    |   0.0 |  1.22
Other   |            | 0.02176    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5462.00 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277170.0 ave      277170 max      277170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277170
Ave neighs/atom = 138.58500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.561315989995, Press = -0.232463486393207
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  136000   -7873.6171   -7873.6171   -7949.3649   -7949.3649    293.15171    293.15171    23375.591    23375.591     801.7144     801.7144 
  137000   -7873.6116   -7873.6116   -7951.7648   -7951.7648    302.46065    302.46065     23386.71     23386.71   -38.199774   -38.199774 
Loop time of 11.5072 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.508 ns/day, 3.196 hours/ns, 86.902 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.307     | 11.307     | 11.307     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039866   | 0.039866   | 0.039866   |   0.0 |  0.35
Output  | 8.4815e-05 | 8.4815e-05 | 8.4815e-05 |   0.0 |  0.00
Modify  | 0.13938    | 0.13938    | 0.13938    |   0.0 |  1.21
Other   |            | 0.02116    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5465.00 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277370.0 ave      277370 max      277370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277370
Ave neighs/atom = 138.68500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.562605019765, Press = -0.353317262718421
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  137000   -7873.6116   -7873.6116   -7951.7648   -7951.7648    302.46065    302.46065     23386.71     23386.71   -38.199774   -38.199774 
  138000   -7875.6291   -7875.6291   -7949.8379   -7949.8379     287.1958     287.1958    23384.841    23384.841    406.76548    406.76548 
Loop time of 11.6385 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.424 ns/day, 3.233 hours/ns, 85.922 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.432     | 11.432     | 11.432     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04054    | 0.04054    | 0.04054    |   0.0 |  0.35
Output  | 6.7652e-05 | 6.7652e-05 | 6.7652e-05 |   0.0 |  0.00
Modify  | 0.14369    | 0.14369    | 0.14369    |   0.0 |  1.23
Other   |            | 0.02207    |            |       |  0.19

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

Total # of neighbors = 277076
Ave neighs/atom = 138.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 = 293.583376329095, Press = -0.245026494679338
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  138000   -7875.6291   -7875.6291   -7949.8379   -7949.8379     287.1958     287.1958    23384.841    23384.841    406.76548    406.76548 
  139000   -7874.9444   -7874.9444    -7951.291    -7951.291    295.46942    295.46942    23394.106    23394.106   -711.90574   -711.90574 
Loop time of 11.551 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.480 ns/day, 3.209 hours/ns, 86.573 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.349     | 11.349     | 11.349     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040048   | 0.040048   | 0.040048   |   0.0 |  0.35
Output  | 7.2491e-05 | 7.2491e-05 | 7.2491e-05 |   0.0 |  0.00
Modify  | 0.14082    | 0.14082    | 0.14082    |   0.0 |  1.22
Other   |            | 0.02117    |            |       |  0.18

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

Total # of neighbors = 277006
Ave neighs/atom = 138.50300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.577752500779, Press = -0.433883155029256
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  139000   -7874.9444   -7874.9444    -7951.291    -7951.291    295.46942    295.46942    23394.106    23394.106   -711.90574   -711.90574 
  140000   -7875.2481   -7875.2481   -7951.5882   -7951.5882    295.44411    295.44411    23412.905    23412.905   -2205.6821   -2205.6821 
Loop time of 11.6478 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.418 ns/day, 3.236 hours/ns, 85.853 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.442     | 11.442     | 11.442     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040737   | 0.040737   | 0.040737   |   0.0 |  0.35
Output  | 8.0711e-05 | 8.0711e-05 | 8.0711e-05 |   0.0 |  0.00
Modify  | 0.14373    | 0.14373    | 0.14373    |   0.0 |  1.23
Other   |            | 0.02141    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5462.00 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277026.0 ave      277026 max      277026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277026
Ave neighs/atom = 138.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 = 293.564819541119, Press = -0.783393491139961
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  140000   -7875.2481   -7875.2481   -7951.5882   -7951.5882    295.44411    295.44411    23412.905    23412.905   -2205.6821   -2205.6821 
  141000   -7874.0674   -7874.0674   -7948.7041   -7948.7041    288.85203    288.85203     23414.04     23414.04   -1575.6889   -1575.6889 
Loop time of 11.649 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.417 ns/day, 3.236 hours/ns, 85.844 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.443     | 11.443     | 11.443     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040655   | 0.040655   | 0.040655   |   0.0 |  0.35
Output  | 7.8986e-05 | 7.8986e-05 | 7.8986e-05 |   0.0 |  0.00
Modify  | 0.14353    | 0.14353    | 0.14353    |   0.0 |  1.23
Other   |            | 0.02148    |            |       |  0.18

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

Total # of neighbors = 276872
Ave neighs/atom = 138.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 = 293.544976735486, Press = -0.242649035785017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  141000   -7874.0674   -7874.0674   -7948.7041   -7948.7041    288.85203    288.85203     23414.04     23414.04   -1575.6889   -1575.6889 
  142000    -7876.493    -7876.493   -7951.1683   -7951.1683    289.00122    289.00122    23388.347    23388.347   -156.56222   -156.56222 
Loop time of 11.7619 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.346 ns/day, 3.267 hours/ns, 85.020 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.552     | 11.552     | 11.552     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041126   | 0.041126   | 0.041126   |   0.0 |  0.35
Output  | 8.3347e-05 | 8.3347e-05 | 8.3347e-05 |   0.0 |  0.00
Modify  | 0.14684    | 0.14684    | 0.14684    |   0.0 |  1.25
Other   |            | 0.02194    |            |       |  0.19

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

Total # of neighbors = 276774
Ave neighs/atom = 138.38700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.548623202494, Press = 0.0101162185377887
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  142000    -7876.493    -7876.493   -7951.1683   -7951.1683    289.00122    289.00122    23388.347    23388.347   -156.56222   -156.56222 
  143000   -7873.4923   -7873.4923   -7949.2694   -7949.2694    293.26515    293.26515    23394.838    23394.838   -501.91592   -501.91592 
Loop time of 11.6206 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.435 ns/day, 3.228 hours/ns, 86.054 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.416     | 11.416     | 11.416     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040511   | 0.040511   | 0.040511   |   0.0 |  0.35
Output  | 6.4418e-05 | 6.4418e-05 | 6.4418e-05 |   0.0 |  0.00
Modify  | 0.14258    | 0.14258    | 0.14258    |   0.0 |  1.23
Other   |            | 0.02145    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5462.00 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277038.0 ave      277038 max      277038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277038
Ave neighs/atom = 138.51900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.564669618947, Press = -0.0399227041493036
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  143000   -7873.4923   -7873.4923   -7949.2694   -7949.2694    293.26515    293.26515    23394.838    23394.838   -501.91592   -501.91592 
  144000   -7876.9894   -7876.9894   -7952.2778   -7952.2778    291.37389    291.37389    23383.228    23383.228    16.697616    16.697616 
Loop time of 11.5387 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.488 ns/day, 3.205 hours/ns, 86.665 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.336     | 11.336     | 11.336     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039973   | 0.039973   | 0.039973   |   0.0 |  0.35
Output  | 8.0512e-05 | 8.0512e-05 | 8.0512e-05 |   0.0 |  0.00
Modify  | 0.14111    | 0.14111    | 0.14111    |   0.0 |  1.22
Other   |            | 0.02107    |            |       |  0.18

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

Total # of neighbors = 277116
Ave neighs/atom = 138.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 = 293.573441022733, Press = 0.00534497799127362
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  144000   -7876.9894   -7876.9894   -7952.2778   -7952.2778    291.37389    291.37389    23383.228    23383.228    16.697616    16.697616 
  145000   -7878.0235   -7878.0235    -7951.936    -7951.936    286.04889    286.04889    23403.214    23403.214   -1521.1568   -1521.1568 
Loop time of 11.6667 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.406 ns/day, 3.241 hours/ns, 85.714 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.459     | 11.459     | 11.459     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040733   | 0.040733   | 0.040733   |   0.0 |  0.35
Output  | 0.00019108 | 0.00019108 | 0.00019108 |   0.0 |  0.00
Modify  | 0.14474    | 0.14474    | 0.14474    |   0.0 |  1.24
Other   |            | 0.02164    |            |       |  0.19

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

Total # of neighbors = 276974
Ave neighs/atom = 138.48700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.576685295244, Press = -0.124084538574352
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  145000   -7878.0235   -7878.0235    -7951.936    -7951.936    286.04889    286.04889    23403.214    23403.214   -1521.1568   -1521.1568 
  146000    -7876.494    -7876.494   -7950.9474   -7950.9474    288.14218    288.14218    23417.929    23417.929   -2484.5619   -2484.5619 
Loop time of 11.4738 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.530 ns/day, 3.187 hours/ns, 87.155 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.274     | 11.274     | 11.274     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039617   | 0.039617   | 0.039617   |   0.0 |  0.35
Output  | 7.7941e-05 | 7.7941e-05 | 7.7941e-05 |   0.0 |  0.00
Modify  | 0.13898    | 0.13898    | 0.13898    |   0.0 |  1.21
Other   |            | 0.02107    |            |       |  0.18

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

Total # of neighbors = 276688
Ave neighs/atom = 138.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 = 293.554164072571, Press = -0.203875755741166
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  146000    -7876.494    -7876.494   -7950.9474   -7950.9474    288.14218    288.14218    23417.929    23417.929   -2484.5619   -2484.5619 
  147000    -7876.318    -7876.318    -7953.085    -7953.085    297.09633    297.09633    23414.086    23414.086   -2260.9642   -2260.9642 
Loop time of 11.6582 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.411 ns/day, 3.238 hours/ns, 85.776 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.452     | 11.452     | 11.452     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040588   | 0.040588   | 0.040588   |   0.0 |  0.35
Output  | 8.0594e-05 | 8.0594e-05 | 8.0594e-05 |   0.0 |  0.00
Modify  | 0.1437     | 0.1437     | 0.1437     |   0.0 |  1.23
Other   |            | 0.02148    |            |       |  0.18

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

Total # of neighbors = 276816
Ave neighs/atom = 138.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 = 293.547658232608, Press = -0.207597013865008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  147000    -7876.318    -7876.318    -7953.085    -7953.085    297.09633    297.09633    23414.086    23414.086   -2260.9642   -2260.9642 
  148000   -7872.7814   -7872.7814   -7950.1704   -7950.1704    299.50365    299.50365    23414.935    23414.935   -2110.3701   -2110.3701 
Loop time of 11.7726 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.339 ns/day, 3.270 hours/ns, 84.943 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.562     | 11.562     | 11.562     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041126   | 0.041126   | 0.041126   |   0.0 |  0.35
Output  | 0.00020776 | 0.00020776 | 0.00020776 |   0.0 |  0.00
Modify  | 0.14708    | 0.14708    | 0.14708    |   0.0 |  1.25
Other   |            | 0.02202    |            |       |  0.19

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

Total # of neighbors = 276602
Ave neighs/atom = 138.30100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.534345346873, Press = -0.100312250616758
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  148000   -7872.7814   -7872.7814   -7950.1704   -7950.1704    299.50365    299.50365    23414.935    23414.935   -2110.3701   -2110.3701 
  149000   -7876.2106   -7876.2106   -7951.3784   -7951.3784    290.90715    290.90715    23402.949    23402.949   -1498.6784   -1498.6784 
Loop time of 11.4842 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.523 ns/day, 3.190 hours/ns, 87.076 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.284     | 11.284     | 11.284     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039871   | 0.039871   | 0.039871   |   0.0 |  0.35
Output  | 0.00010038 | 0.00010038 | 0.00010038 |   0.0 |  0.00
Modify  | 0.13964    | 0.13964    | 0.13964    |   0.0 |  1.22
Other   |            | 0.02095    |            |       |  0.18

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

Total # of neighbors = 276758
Ave neighs/atom = 138.37900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.540401831979, Press = 0.0704828109136958
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  149000   -7876.2106   -7876.2106   -7951.3784   -7951.3784    290.90715    290.90715    23402.949    23402.949   -1498.6784   -1498.6784 
  150000   -7869.8574   -7869.8574   -7947.0602   -7947.0602     298.7831     298.7831    23396.804    23396.804   -418.74344   -418.74344 
Loop time of 11.5731 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.466 ns/day, 3.215 hours/ns, 86.407 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.368     | 11.368     | 11.368     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040506   | 0.040506   | 0.040506   |   0.0 |  0.35
Output  | 0.00013016 | 0.00013016 | 0.00013016 |   0.0 |  0.00
Modify  | 0.14296    | 0.14296    | 0.14296    |   0.0 |  1.24
Other   |            | 0.02168    |            |       |  0.19

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

Total # of neighbors = 276906
Ave neighs/atom = 138.45300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.54706052178, Press = -0.00913844995252203
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  150000   -7869.8574   -7869.8574   -7947.0602   -7947.0602     298.7831     298.7831    23396.804    23396.804   -418.74344   -418.74344 
  151000   -7877.6815   -7877.6815   -7951.7782   -7951.7782    286.76203    286.76203    23392.029    23392.029   -786.10756   -786.10756 
Loop time of 11.8786 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.274 ns/day, 3.300 hours/ns, 84.185 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.664     | 11.664     | 11.664     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041877   | 0.041877   | 0.041877   |   0.0 |  0.35
Output  | 7.5824e-05 | 7.5824e-05 | 7.5824e-05 |   0.0 |  0.00
Modify  | 0.15009    | 0.15009    | 0.15009    |   0.0 |  1.26
Other   |            | 0.02227    |            |       |  0.19

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

Total # of neighbors = 277364
Ave neighs/atom = 138.68200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.554914996226, Press = -0.129633581272777
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  151000   -7877.6815   -7877.6815   -7951.7782   -7951.7782    286.76203    286.76203    23392.029    23392.029   -786.10756   -786.10756 
  152000   -7876.2584   -7876.2584   -7952.8917   -7952.8917    296.57866    296.57866    23430.773    23430.773   -3314.8942   -3314.8942 
Loop time of 11.6264 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.431 ns/day, 3.230 hours/ns, 86.011 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.421     | 11.421     | 11.421     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040695   | 0.040695   | 0.040695   |   0.0 |  0.35
Output  | 8.1334e-05 | 8.1334e-05 | 8.1334e-05 |   0.0 |  0.00
Modify  | 0.14278    | 0.14278    | 0.14278    |   0.0 |  1.23
Other   |            | 0.02149    |            |       |  0.18

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

Total # of neighbors = 277176
Ave neighs/atom = 138.58800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.554378231115, Press = -0.25399834373406
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  152000   -7876.2584   -7876.2584   -7952.8917   -7952.8917    296.57866    296.57866    23430.773    23430.773   -3314.8942   -3314.8942 
  153000   -7878.0832   -7878.0832   -7952.5654   -7952.5654    288.25412    288.25412    23436.156    23436.156   -3677.0084   -3677.0084 
Loop time of 12.0678 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.160 ns/day, 3.352 hours/ns, 82.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.847     | 11.847     | 11.847     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042735   | 0.042735   | 0.042735   |   0.0 |  0.35
Output  | 6.194e-05  | 6.194e-05  | 6.194e-05  |   0.0 |  0.00
Modify  | 0.15484    | 0.15484    | 0.15484    |   0.0 |  1.28
Other   |            | 0.02282    |            |       |  0.19

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

Total # of neighbors = 276552
Ave neighs/atom = 138.27600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.561305260573, Press = 0.0666027239161825
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  153000   -7878.0832   -7878.0832   -7952.5654   -7952.5654    288.25412    288.25412    23436.156    23436.156   -3677.0084   -3677.0084 
  154000   -7872.8859   -7872.8859   -7947.7645   -7947.7645     289.7878     289.7878    23414.995    23414.995   -1664.0136   -1664.0136 
Loop time of 11.793 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.326 ns/day, 3.276 hours/ns, 84.796 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.582     | 11.582     | 11.582     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041472   | 0.041472   | 0.041472   |   0.0 |  0.35
Output  | 8.7632e-05 | 8.7632e-05 | 8.7632e-05 |   0.0 |  0.00
Modify  | 0.14742    | 0.14742    | 0.14742    |   0.0 |  1.25
Other   |            | 0.02198    |            |       |  0.19

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

Total # of neighbors = 276408
Ave neighs/atom = 138.20400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.557695302473, Press = 0.308729192883948
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  154000   -7872.8859   -7872.8859   -7947.7645   -7947.7645     289.7878     289.7878    23414.995    23414.995   -1664.0136   -1664.0136 
  155000   -7875.7762   -7875.7762   -7950.4403   -7950.4403    288.95794    288.95794    23390.276    23390.276   -407.06447   -407.06447 
Loop time of 11.6016 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.447 ns/day, 3.223 hours/ns, 86.195 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.394     | 11.394     | 11.394     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04071    | 0.04071    | 0.04071    |   0.0 |  0.35
Output  | 6.3682e-05 | 6.3682e-05 | 6.3682e-05 |   0.0 |  0.00
Modify  | 0.14417    | 0.14417    | 0.14417    |   0.0 |  1.24
Other   |            | 0.02299    |            |       |  0.20

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

Total # of neighbors = 276940
Ave neighs/atom = 138.47000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.575135583142, Press = 0.283518033016404
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  155000   -7875.7762   -7875.7762   -7950.4403   -7950.4403    288.95794    288.95794    23390.276    23390.276   -407.06447   -407.06447 
  156000   -7873.9742   -7873.9742   -7951.1225   -7951.1225    298.57185    298.57185    23383.002    23383.002    138.29805    138.29805 
Loop time of 11.8227 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.308 ns/day, 3.284 hours/ns, 84.583 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.611     | 11.611     | 11.611     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041646   | 0.041646   | 0.041646   |   0.0 |  0.35
Output  | 8.7874e-05 | 8.7874e-05 | 8.7874e-05 |   0.0 |  0.00
Modify  | 0.14786    | 0.14786    | 0.14786    |   0.0 |  1.25
Other   |            | 0.022      |            |       |  0.19

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

Total # of neighbors = 276852
Ave neighs/atom = 138.42600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.573195759728, Press = 0.392439498569886
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  156000   -7873.9742   -7873.9742   -7951.1225   -7951.1225    298.57185    298.57185    23383.002    23383.002    138.29805    138.29805 
  157000   -7876.4662   -7876.4662   -7951.1199   -7951.1199    288.91732    288.91732    23364.418    23364.418    1412.9678    1412.9678 
Loop time of 11.5559 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.477 ns/day, 3.210 hours/ns, 86.536 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.353     | 11.353     | 11.353     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040276   | 0.040276   | 0.040276   |   0.0 |  0.35
Output  | 6.2227e-05 | 6.2227e-05 | 6.2227e-05 |   0.0 |  0.00
Modify  | 0.14137    | 0.14137    | 0.14137    |   0.0 |  1.22
Other   |            | 0.0211     |            |       |  0.18

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

Total # of neighbors = 277142
Ave neighs/atom = 138.57100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.589353503186, Press = 0.432349648837196
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  157000   -7876.4662   -7876.4662   -7951.1199   -7951.1199    288.91732    288.91732    23364.418    23364.418    1412.9678    1412.9678 
  158000   -7877.4659   -7877.4659   -7952.5653   -7952.5653    290.64209    290.64209    23341.142    23341.142    2614.0866    2614.0866 
Loop time of 11.741 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.359 ns/day, 3.261 hours/ns, 85.172 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.532     | 11.532     | 11.532     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041389   | 0.041389   | 0.041389   |   0.0 |  0.35
Output  | 6.3926e-05 | 6.3926e-05 | 6.3926e-05 |   0.0 |  0.00
Modify  | 0.14597    | 0.14597    | 0.14597    |   0.0 |  1.24
Other   |            | 0.0217     |            |       |  0.18

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

Total # of neighbors = 277358
Ave neighs/atom = 138.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 = 293.58609692558, Press = 0.441500191564558
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  158000   -7877.4659   -7877.4659   -7952.5653   -7952.5653    290.64209    290.64209    23341.142    23341.142    2614.0866    2614.0866 
  159000    -7870.086    -7870.086    -7949.916    -7949.916    308.95026    308.95026    23336.068    23336.068    3752.2345    3752.2345 
Loop time of 11.4478 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.547 ns/day, 3.180 hours/ns, 87.353 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.248     | 11.248     | 11.248     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039806   | 0.039806   | 0.039806   |   0.0 |  0.35
Output  | 0.00019089 | 0.00019089 | 0.00019089 |   0.0 |  0.00
Modify  | 0.13879    | 0.13879    | 0.13879    |   0.0 |  1.21
Other   |            | 0.02084    |            |       |  0.18

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

Total # of neighbors = 277538
Ave neighs/atom = 138.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 = 293.59167460626, Press = 0.102201476945093
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  159000    -7870.086    -7870.086    -7949.916    -7949.916    308.95026    308.95026    23336.068    23336.068    3752.2345    3752.2345 
  160000   -7876.5541   -7876.5541   -7951.4618   -7951.4618    289.90034    289.90034    23348.957    23348.957    2377.1062    2377.1062 
Loop time of 11.4997 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.513 ns/day, 3.194 hours/ns, 86.959 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.299     | 11.299     | 11.299     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039979   | 0.039979   | 0.039979   |   0.0 |  0.35
Output  | 8.4466e-05 | 8.4466e-05 | 8.4466e-05 |   0.0 |  0.00
Modify  | 0.13952    | 0.13952    | 0.13952    |   0.0 |  1.21
Other   |            | 0.02103    |            |       |  0.18

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

Total # of neighbors = 277528
Ave neighs/atom = 138.76400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.597739927972, Press = -0.044772039784887
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  160000   -7876.5541   -7876.5541   -7951.4618   -7951.4618    289.90034    289.90034    23348.957    23348.957    2377.1062    2377.1062 
  161000   -7878.6832   -7878.6832   -7954.0026   -7954.0026    291.49387    291.49387     23361.97     23361.97    1135.5198    1135.5198 
Loop time of 11.5717 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.466 ns/day, 3.214 hours/ns, 86.418 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.368     | 11.368     | 11.368     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04036    | 0.04036    | 0.04036    |   0.0 |  0.35
Output  | 8.1421e-05 | 8.1421e-05 | 8.1421e-05 |   0.0 |  0.00
Modify  | 0.14195    | 0.14195    | 0.14195    |   0.0 |  1.23
Other   |            | 0.02158    |            |       |  0.19

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

Total # of neighbors = 277314
Ave neighs/atom = 138.65700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.595994833339, Press = -0.0361335890044719
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  161000   -7878.6832   -7878.6832   -7954.0026   -7954.0026    291.49387    291.49387     23361.97     23361.97    1135.5198    1135.5198 
  162000   -7875.3046   -7875.3046   -7951.7061   -7951.7061    295.68162    295.68162    23360.385    23360.385    1781.9207    1781.9207 
Loop time of 11.7456 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.356 ns/day, 3.263 hours/ns, 85.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.537     | 11.537     | 11.537     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041103   | 0.041103   | 0.041103   |   0.0 |  0.35
Output  | 8.6725e-05 | 8.6725e-05 | 8.6725e-05 |   0.0 |  0.00
Modify  | 0.14585    | 0.14585    | 0.14585    |   0.0 |  1.24
Other   |            | 0.02169    |            |       |  0.18

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

Total # of neighbors = 276898
Ave neighs/atom = 138.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 = 293.575921194527, Press = -0.204375708742215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  162000   -7875.3046   -7875.3046   -7951.7061   -7951.7061    295.68162    295.68162    23360.385    23360.385    1781.9207    1781.9207 
  163000   -7877.1029   -7877.1029   -7953.2057   -7953.2057    294.52576    294.52576    23364.865    23364.865    1053.2255    1053.2255 
Loop time of 11.6934 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.389 ns/day, 3.248 hours/ns, 85.518 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.485     | 11.485     | 11.485     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040898   | 0.040898   | 0.040898   |   0.0 |  0.35
Output  | 9.562e-05  | 9.562e-05  | 9.562e-05  |   0.0 |  0.00
Modify  | 0.14533    | 0.14533    | 0.14533    |   0.0 |  1.24
Other   |            | 0.02175    |            |       |  0.19

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

Total # of neighbors = 277032
Ave neighs/atom = 138.51600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.570170878014, Press = -0.174394018682976
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  163000   -7877.1029   -7877.1029   -7953.2057   -7953.2057    294.52576    294.52576    23364.865    23364.865    1053.2255    1053.2255 
  164000   -7876.2994   -7876.2994   -7950.5993   -7950.5993    287.54822    287.54822    23379.777    23379.777    267.28342    267.28342 
Loop time of 11.9451 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.233 ns/day, 3.318 hours/ns, 83.716 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.727     | 11.727     | 11.727     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042294   | 0.042294   | 0.042294   |   0.0 |  0.35
Output  | 8.1815e-05 | 8.1815e-05 | 8.1815e-05 |   0.0 |  0.00
Modify  | 0.15278    | 0.15278    | 0.15278    |   0.0 |  1.28
Other   |            | 0.02313    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276842.0 ave      276842 max      276842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276842
Ave neighs/atom = 138.42100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.55331536466, Press = -0.0112935656607462
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  164000   -7876.2994   -7876.2994   -7950.5993   -7950.5993    287.54822    287.54822    23379.777    23379.777    267.28342    267.28342 
  165000   -7876.6048   -7876.6048   -7949.8909   -7949.8909    283.62462    283.62462    23392.292    23392.292   -698.96696   -698.96696 
Loop time of 11.6241 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.433 ns/day, 3.229 hours/ns, 86.029 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.42      | 11.42      | 11.42      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040573   | 0.040573   | 0.040573   |   0.0 |  0.35
Output  | 6.2487e-05 | 6.2487e-05 | 6.2487e-05 |   0.0 |  0.00
Modify  | 0.14222    | 0.14222    | 0.14222    |   0.0 |  1.22
Other   |            | 0.02133    |            |       |  0.18

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

Total # of neighbors = 277138
Ave neighs/atom = 138.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 = 293.548535424969, Press = -0.157813625551397
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  165000   -7876.6048   -7876.6048   -7949.8909   -7949.8909    283.62462    283.62462    23392.292    23392.292   -698.96696   -698.96696 
  166000   -7875.2633   -7875.2633   -7952.2937   -7952.2937    298.11569    298.11569     23396.63     23396.63   -977.03964   -977.03964 
Loop time of 11.6358 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.425 ns/day, 3.232 hours/ns, 85.942 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.429     | 11.429     | 11.429     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040697   | 0.040697   | 0.040697   |   0.0 |  0.35
Output  | 0.00019563 | 0.00019563 | 0.00019563 |   0.0 |  0.00
Modify  | 0.14381    | 0.14381    | 0.14381    |   0.0 |  1.24
Other   |            | 0.02167    |            |       |  0.19

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

Total # of neighbors = 276934
Ave neighs/atom = 138.46700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.528447564521, Press = 0.0687377425081472
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  166000   -7875.2633   -7875.2633   -7952.2937   -7952.2937    298.11569    298.11569     23396.63     23396.63   -977.03964   -977.03964 
  167000   -7875.1108   -7875.1108   -7950.1182   -7950.1182    290.28632    290.28632    23407.922    23407.922   -1291.6533   -1291.6533 
Loop time of 11.492 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.518 ns/day, 3.192 hours/ns, 87.017 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.29      | 11.29      | 11.29      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039949   | 0.039949   | 0.039949   |   0.0 |  0.35
Output  | 8.3136e-05 | 8.3136e-05 | 8.3136e-05 |   0.0 |  0.00
Modify  | 0.14034    | 0.14034    | 0.14034    |   0.0 |  1.22
Other   |            | 0.02138    |            |       |  0.19

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

Total # of neighbors = 276888
Ave neighs/atom = 138.44400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.517512169232, Press = 0.0559006115241902
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  167000   -7875.1108   -7875.1108   -7950.1182   -7950.1182    290.28632    290.28632    23407.922    23407.922   -1291.6533   -1291.6533 
  168000   -7872.5007   -7872.5007   -7949.1211   -7949.1211    296.52864    296.52864    23441.896    23441.896   -4031.9699   -4031.9699 
Loop time of 11.6291 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.430 ns/day, 3.230 hours/ns, 85.992 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.423     | 11.423     | 11.423     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040613   | 0.040613   | 0.040613   |   0.0 |  0.35
Output  | 8.6058e-05 | 8.6058e-05 | 8.6058e-05 |   0.0 |  0.00
Modify  | 0.14338    | 0.14338    | 0.14338    |   0.0 |  1.23
Other   |            | 0.02151    |            |       |  0.18

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

Total # of neighbors = 276618
Ave neighs/atom = 138.30900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.508540661107, Press = 0.100633892861885
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  168000   -7872.5007   -7872.5007   -7949.1211   -7949.1211    296.52864    296.52864    23441.896    23441.896   -4031.9699   -4031.9699 
  169000   -7875.9579   -7875.9579   -7951.7786   -7951.7786    293.43364    293.43364    23429.529    23429.529   -3259.0723   -3259.0723 
Loop time of 11.6543 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.414 ns/day, 3.237 hours/ns, 85.805 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.448     | 11.448     | 11.448     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040895   | 0.040895   | 0.040895   |   0.0 |  0.35
Output  | 8.22e-05   | 8.22e-05   | 8.22e-05   |   0.0 |  0.00
Modify  | 0.14355    | 0.14355    | 0.14355    |   0.0 |  1.23
Other   |            | 0.0214     |            |       |  0.18

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

Total # of neighbors = 276484
Ave neighs/atom = 138.24200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.510711284439, Press = 0.341816635135514
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  169000   -7875.9579   -7875.9579   -7951.7786   -7951.7786    293.43364    293.43364    23429.529    23429.529   -3259.0723   -3259.0723 
  170000   -7872.7133   -7872.7133   -7951.3746   -7951.3746    304.42729    304.42729    23414.912    23414.912    -1965.145    -1965.145 
Loop time of 11.7214 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.371 ns/day, 3.256 hours/ns, 85.314 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.513     | 11.513     | 11.513     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041      | 0.041      | 0.041      |   0.0 |  0.35
Output  | 8.4834e-05 | 8.4834e-05 | 8.4834e-05 |   0.0 |  0.00
Modify  | 0.14582    | 0.14582    | 0.14582    |   0.0 |  1.24
Other   |            | 0.022      |            |       |  0.19

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

Total # of neighbors = 276588
Ave neighs/atom = 138.29400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.511500202402, Press = 0.354208723860754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  170000   -7872.7133   -7872.7133   -7951.3746   -7951.3746    304.42729    304.42729    23414.912    23414.912    -1965.145    -1965.145 
  171000   -7878.4904   -7878.4904   -7953.3271   -7953.3271    289.62581    289.62581    23390.687    23390.687   -828.63728   -828.63728 
Loop time of 11.6525 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.415 ns/day, 3.237 hours/ns, 85.818 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.446     | 11.446     | 11.446     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040835   | 0.040835   | 0.040835   |   0.0 |  0.35
Output  | 8.0537e-05 | 8.0537e-05 | 8.0537e-05 |   0.0 |  0.00
Modify  | 0.14443    | 0.14443    | 0.14443    |   0.0 |  1.24
Other   |            | 0.02161    |            |       |  0.19

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

Total # of neighbors = 276804
Ave neighs/atom = 138.40200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.507402403169, Press = 0.301311108703385
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  171000   -7878.4904   -7878.4904   -7953.3271   -7953.3271    289.62581    289.62581    23390.687    23390.687   -828.63728   -828.63728 
  172000   -7873.4563   -7873.4563    -7949.732    -7949.732    295.19497    295.19497    23373.632    23373.632     1012.191     1012.191 
Loop time of 11.6214 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.435 ns/day, 3.228 hours/ns, 86.048 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.415     | 11.415     | 11.415     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040747   | 0.040747   | 0.040747   |   0.0 |  0.35
Output  | 7.0704e-05 | 7.0704e-05 | 7.0704e-05 |   0.0 |  0.00
Modify  | 0.14384    | 0.14384    | 0.14384    |   0.0 |  1.24
Other   |            | 0.02169    |            |       |  0.19

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

Total # of neighbors = 276834
Ave neighs/atom = 138.41700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.493956497816, Press = 0.399383154247395
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  172000   -7873.4563   -7873.4563    -7949.732    -7949.732    295.19497    295.19497    23373.632    23373.632     1012.191     1012.191 
  173000   -7874.4409   -7874.4409   -7950.3371   -7950.3371    293.72629    293.72629    23373.278    23373.278    406.68682    406.68682 
Loop time of 11.5849 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.458 ns/day, 3.218 hours/ns, 86.319 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.381     | 11.381     | 11.381     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040215   | 0.040215   | 0.040215   |   0.0 |  0.35
Output  | 6.5165e-05 | 6.5165e-05 | 6.5165e-05 |   0.0 |  0.00
Modify  | 0.14181    | 0.14181    | 0.14181    |   0.0 |  1.22
Other   |            | 0.02143    |            |       |  0.18

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

Total # of neighbors = 277130
Ave neighs/atom = 138.56500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.495079635081, Press = 0.254740441382267
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  173000   -7874.4409   -7874.4409   -7950.3371   -7950.3371    293.72629    293.72629    23373.278    23373.278    406.68682    406.68682 
  174000   -7877.2119   -7877.2119   -7951.6694   -7951.6694    288.15794    288.15794     23362.29     23362.29    1539.0935    1539.0935 
Loop time of 11.5416 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.486 ns/day, 3.206 hours/ns, 86.643 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.339     | 11.339     | 11.339     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040182   | 0.040182   | 0.040182   |   0.0 |  0.35
Output  | 0.00019949 | 0.00019949 | 0.00019949 |   0.0 |  0.00
Modify  | 0.14071    | 0.14071    | 0.14071    |   0.0 |  1.22
Other   |            | 0.02128    |            |       |  0.18

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

Total # of neighbors = 277416
Ave neighs/atom = 138.70800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.508463447153, Press = -0.138465771022089
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  174000   -7877.2119   -7877.2119   -7951.6694   -7951.6694    288.15794    288.15794     23362.29     23362.29    1539.0935    1539.0935 
  175000   -7874.3252   -7874.3252   -7949.7612   -7949.7612    291.94503    291.94503    23374.788    23374.788    607.93243    607.93243 
Loop time of 11.8731 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.277 ns/day, 3.298 hours/ns, 84.224 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.66      | 11.66      | 11.66      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041707   | 0.041707   | 0.041707   |   0.0 |  0.35
Output  | 6.2568e-05 | 6.2568e-05 | 6.2568e-05 |   0.0 |  0.00
Modify  | 0.14959    | 0.14959    | 0.14959    |   0.0 |  1.26
Other   |            | 0.02223    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5468.00 ave        5468 max        5468 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277070.0 ave      277070 max      277070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277070
Ave neighs/atom = 138.53500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.495532875156, Press = -0.517222786779846
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  175000   -7874.3252   -7874.3252   -7949.7612   -7949.7612    291.94503    291.94503    23374.788    23374.788    607.93243    607.93243 
  176000   -7879.2086   -7879.2086   -7955.2442   -7955.2442     294.2657     294.2657    23411.025    23411.025   -2328.2023   -2328.2023 
Loop time of 11.5553 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.477 ns/day, 3.210 hours/ns, 86.541 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.351     | 11.351     | 11.351     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040288   | 0.040288   | 0.040288   |   0.0 |  0.35
Output  | 0.00021803 | 0.00021803 | 0.00021803 |   0.0 |  0.00
Modify  | 0.14187    | 0.14187    | 0.14187    |   0.0 |  1.23
Other   |            | 0.02158    |            |       |  0.19

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

Total # of neighbors = 277360
Ave neighs/atom = 138.68000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.484559072085, Press = -0.191680547985976
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  176000   -7879.2086   -7879.2086   -7955.2442   -7955.2442     294.2657     294.2657    23411.025    23411.025   -2328.2023   -2328.2023 
  177000   -7874.4013   -7874.4013   -7951.4587   -7951.4587    298.21975    298.21975    23423.827    23423.827   -2497.1006   -2497.1006 
Loop time of 11.6116 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.441 ns/day, 3.225 hours/ns, 86.121 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.405     | 11.405     | 11.405     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040738   | 0.040738   | 0.040738   |   0.0 |  0.35
Output  | 9.4653e-05 | 9.4653e-05 | 9.4653e-05 |   0.0 |  0.00
Modify  | 0.14342    | 0.14342    | 0.14342    |   0.0 |  1.24
Other   |            | 0.02196    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5456.00 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276394.0 ave      276394 max      276394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276394
Ave neighs/atom = 138.19700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.473382527522, Press = -0.0015402220762645
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  177000   -7874.4013   -7874.4013   -7951.4587   -7951.4587    298.21975    298.21975    23423.827    23423.827   -2497.1006   -2497.1006 
  178000   -7876.0055   -7876.0055   -7951.7425   -7951.7425    293.10986    293.10986    23402.844    23402.844   -1548.8023   -1548.8023 
Loop time of 11.8024 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.321 ns/day, 3.278 hours/ns, 84.729 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.59      | 11.59      | 11.59      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041472   | 0.041472   | 0.041472   |   0.0 |  0.35
Output  | 0.00020599 | 0.00020599 | 0.00020599 |   0.0 |  0.00
Modify  | 0.14803    | 0.14803    | 0.14803    |   0.0 |  1.25
Other   |            | 0.02217    |            |       |  0.19

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

Total # of neighbors = 276368
Ave neighs/atom = 138.18400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.462493202027, Press = -0.117621624247917
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  178000   -7876.0055   -7876.0055   -7951.7425   -7951.7425    293.10986    293.10986    23402.844    23402.844   -1548.8023   -1548.8023 
  179000   -7874.3761   -7874.3761   -7950.3863   -7950.3863    294.16705    294.16705    23400.069    23400.069   -902.55927   -902.55927 
Loop time of 11.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.411 ns/day, 3.238 hours/ns, 85.778 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.45      | 11.45      | 11.45      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040864   | 0.040864   | 0.040864   |   0.0 |  0.35
Output  | 0.0002159  | 0.0002159  | 0.0002159  |   0.0 |  0.00
Modify  | 0.1451     | 0.1451     | 0.1451     |   0.0 |  1.24
Other   |            | 0.02186    |            |       |  0.19

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

Total # of neighbors = 276820
Ave neighs/atom = 138.41000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.454876042836, Press = 0.109921729131183
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  179000   -7874.3761   -7874.3761   -7950.3863   -7950.3863    294.16705    294.16705    23400.069    23400.069   -902.55927   -902.55927 
  180000   -7875.9473   -7875.9473   -7951.4982   -7951.4982       292.39       292.39    23407.287    23407.287   -1667.8427   -1667.8427 
Loop time of 11.9399 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.236 ns/day, 3.317 hours/ns, 83.753 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.723     | 11.723     | 11.723     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042176   | 0.042176   | 0.042176   |   0.0 |  0.35
Output  | 9.3852e-05 | 9.3852e-05 | 9.3852e-05 |   0.0 |  0.00
Modify  | 0.15182    | 0.15182    | 0.15182    |   0.0 |  1.27
Other   |            | 0.02244    |            |       |  0.19

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

Total # of neighbors = 276874
Ave neighs/atom = 138.43700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.452218500323, Press = 0.347026885466374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  180000   -7875.9473   -7875.9473   -7951.4982   -7951.4982       292.39       292.39    23407.287    23407.287   -1667.8427   -1667.8427 
  181000    -7873.405    -7873.405   -7951.9911   -7951.9911    304.13659    304.13659    23410.891    23410.891   -1710.1535   -1710.1535 
Loop time of 11.5404 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.487 ns/day, 3.206 hours/ns, 86.652 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.338     | 11.338     | 11.338     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040129   | 0.040129   | 0.040129   |   0.0 |  0.35
Output  | 8.5491e-05 | 8.5491e-05 | 8.5491e-05 |   0.0 |  0.00
Modify  | 0.14099    | 0.14099    | 0.14099    |   0.0 |  1.22
Other   |            | 0.02099    |            |       |  0.18

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

Total # of neighbors = 276648
Ave neighs/atom = 138.32400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.453419058796, Press = 0.451219485210473
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  181000    -7873.405    -7873.405   -7951.9911   -7951.9911    304.13659    304.13659    23410.891    23410.891   -1710.1535   -1710.1535 
  182000   -7876.5641   -7876.5641   -7949.7669   -7949.7669    283.30263    283.30263    23400.571    23400.571   -1004.7033   -1004.7033 
Loop time of 11.6199 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.436 ns/day, 3.228 hours/ns, 86.059 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.414     | 11.414     | 11.414     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040535   | 0.040535   | 0.040535   |   0.0 |  0.35
Output  | 8.6288e-05 | 8.6288e-05 | 8.6288e-05 |   0.0 |  0.00
Modify  | 0.14376    | 0.14376    | 0.14376    |   0.0 |  1.24
Other   |            | 0.02159    |            |       |  0.19

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

Total # of neighbors = 276620
Ave neighs/atom = 138.31000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.43874832262, Press = 0.529215079503478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  182000   -7876.5641   -7876.5641   -7949.7669   -7949.7669    283.30263    283.30263    23400.571    23400.571   -1004.7033   -1004.7033 
  183000   -7875.9225   -7875.9225   -7952.3562   -7952.3562    295.80634    295.80634    23370.745    23370.745    999.52524    999.52524 
Loop time of 11.7497 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.353 ns/day, 3.264 hours/ns, 85.109 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.539     | 11.539     | 11.539     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041246   | 0.041246   | 0.041246   |   0.0 |  0.35
Output  | 0.00010108 | 0.00010108 | 0.00010108 |   0.0 |  0.00
Modify  | 0.14722    | 0.14722    | 0.14722    |   0.0 |  1.25
Other   |            | 0.02237    |            |       |  0.19

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

Total # of neighbors = 276872
Ave neighs/atom = 138.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 = 293.430144348147, Press = 0.462707284450674
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  183000   -7875.9225   -7875.9225   -7952.3562   -7952.3562    295.80634    295.80634    23370.745    23370.745    999.52524    999.52524 
  184000   -7872.6909   -7872.6909   -7950.6794   -7950.6794    301.82358    301.82358    23390.915    23390.915   -815.99773   -815.99773 
Loop time of 11.5594 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.474 ns/day, 3.211 hours/ns, 86.510 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.357     | 11.357     | 11.357     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040147   | 0.040147   | 0.040147   |   0.0 |  0.35
Output  | 8.3902e-05 | 8.3902e-05 | 8.3902e-05 |   0.0 |  0.00
Modify  | 0.14134    | 0.14134    | 0.14134    |   0.0 |  1.22
Other   |            | 0.02119    |            |       |  0.18

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

Total # of neighbors = 276970
Ave neighs/atom = 138.48500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.422657012136, Press = 0.215579785811901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  184000   -7872.6909   -7872.6909   -7950.6794   -7950.6794    301.82358    301.82358    23390.915    23390.915   -815.99773   -815.99773 
  185000   -7878.2979   -7878.2979   -7953.6145   -7953.6145    291.48273    291.48273     23375.17     23375.17    234.76468    234.76468 
Loop time of 11.8903 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.266 ns/day, 3.303 hours/ns, 84.102 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.675     | 11.675     | 11.675     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04187    | 0.04187    | 0.04187    |   0.0 |  0.35
Output  | 8.1805e-05 | 8.1805e-05 | 8.1805e-05 |   0.0 |  0.00
Modify  | 0.1506     | 0.1506     | 0.1506     |   0.0 |  1.27
Other   |            | 0.02229    |            |       |  0.19

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

Total # of neighbors = 277084
Ave neighs/atom = 138.54200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.415952243331, Press = 0.161932216233299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  185000   -7878.2979   -7878.2979   -7953.6145   -7953.6145    291.48273    291.48273     23375.17     23375.17    234.76468    234.76468 
  186000    -7875.297    -7875.297   -7952.6036   -7952.6036    299.18422    299.18422    23357.289    23357.289    1843.2059    1843.2059 
Loop time of 11.6748 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.401 ns/day, 3.243 hours/ns, 85.655 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.468     | 11.468     | 11.468     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040626   | 0.040626   | 0.040626   |   0.0 |  0.35
Output  | 0.00019361 | 0.00019361 | 0.00019361 |   0.0 |  0.00
Modify  | 0.14443    | 0.14443    | 0.14443    |   0.0 |  1.24
Other   |            | 0.02179    |            |       |  0.19

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

Total # of neighbors = 277082
Ave neighs/atom = 138.54100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.419029465521, Press = -0.0395890835305783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  186000    -7875.297    -7875.297   -7952.6036   -7952.6036    299.18422    299.18422    23357.289    23357.289    1843.2059    1843.2059 
  187000   -7874.3845   -7874.3845   -7951.6928   -7951.6928    299.19133    299.19133    23338.028    23338.028    3107.5762    3107.5762 
Loop time of 11.6603 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.410 ns/day, 3.239 hours/ns, 85.761 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.453     | 11.453     | 11.453     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040823   | 0.040823   | 0.040823   |   0.0 |  0.35
Output  | 9.9929e-05 | 9.9929e-05 | 9.9929e-05 |   0.0 |  0.00
Modify  | 0.14444    | 0.14444    | 0.14444    |   0.0 |  1.24
Other   |            | 0.02221    |            |       |  0.19

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

Total # of neighbors = 277186
Ave neighs/atom = 138.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 = 293.422348028163, Press = -0.121350354963601
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  187000   -7874.3845   -7874.3845   -7951.6928   -7951.6928    299.19133    299.19133    23338.028    23338.028    3107.5762    3107.5762 
  188000    -7874.161    -7874.161   -7949.9269   -7949.9269    293.22163    293.22163    23347.573    23347.573    2575.3816    2575.3816 
Loop time of 11.8276 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.305 ns/day, 3.285 hours/ns, 84.548 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    | 11.615     | 11.615     | 11.615     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041459   | 0.041459   | 0.041459   |   0.0 |  0.35
Output  | 8.3309e-05 | 8.3309e-05 | 8.3309e-05 |   0.0 |  0.00
Modify  | 0.14831    | 0.14831    | 0.14831    |   0.0 |  1.25
Other   |            | 0.0223     |            |       |  0.19

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

Total # of neighbors = 277512
Ave neighs/atom = 138.75600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.438191625283, Press = -0.502942190421777
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  188000    -7874.161    -7874.161   -7949.9269   -7949.9269    293.22163    293.22163    23347.573    23347.573    2575.3816    2575.3816 
  189000   -7875.0778   -7875.0778   -7952.1215   -7952.1215    298.16703    298.16703    23380.271    23380.271    177.47083    177.47083 
Loop time of 11.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.318 ns/day, 3.280 hours/ns, 84.695 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.596     | 11.596     | 11.596     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041409   | 0.041409   | 0.041409   |   0.0 |  0.35
Output  | 9.7774e-05 | 9.7774e-05 | 9.7774e-05 |   0.0 |  0.00
Modify  | 0.14766    | 0.14766    | 0.14766    |   0.0 |  1.25
Other   |            | 0.02179    |            |       |  0.18

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

Total # of neighbors = 277698
Ave neighs/atom = 138.84900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.439491504973, Press = -0.156394222248137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  189000   -7875.0778   -7875.0778   -7952.1215   -7952.1215    298.16703    298.16703    23380.271    23380.271    177.47083    177.47083 
  190000   -7874.5763   -7874.5763   -7951.5427   -7951.5427    297.86824    297.86824    23391.804    23391.804   -427.26606   -427.26606 
Loop time of 11.863 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.283 ns/day, 3.295 hours/ns, 84.296 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.649     | 11.649     | 11.649     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041774   | 0.041774   | 0.041774   |   0.0 |  0.35
Output  | 8.5437e-05 | 8.5437e-05 | 8.5437e-05 |   0.0 |  0.00
Modify  | 0.14994    | 0.14994    | 0.14994    |   0.0 |  1.26
Other   |            | 0.02228    |            |       |  0.19

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

Total # of neighbors = 277300
Ave neighs/atom = 138.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 = 293.454655082233, Press = -0.101287574551766
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  190000   -7874.5763   -7874.5763   -7951.5427   -7951.5427    297.86824    297.86824    23391.804    23391.804   -427.26606   -427.26606 
  191000   -7873.6156   -7873.6156    -7948.938    -7948.938    291.50533    291.50533    23400.067    23400.067   -895.06162   -895.06162 
Loop time of 11.6704 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.403 ns/day, 3.242 hours/ns, 85.687 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.463     | 11.463     | 11.463     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040692   | 0.040692   | 0.040692   |   0.0 |  0.35
Output  | 6.5918e-05 | 6.5918e-05 | 6.5918e-05 |   0.0 |  0.00
Modify  | 0.1451     | 0.1451     | 0.1451     |   0.0 |  1.24
Other   |            | 0.02179    |            |       |  0.19

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

Total # of neighbors = 276880
Ave neighs/atom = 138.44000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.45330507242, Press = 0.0167750036316439
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  191000   -7873.6156   -7873.6156    -7948.938    -7948.938    291.50533    291.50533    23400.067    23400.067   -895.06162   -895.06162 
  192000   -7880.0667   -7880.0667   -7953.7621   -7953.7621    285.20891    285.20891    23395.236    23395.236   -1277.8417   -1277.8417 
Loop time of 11.5794 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.462 ns/day, 3.217 hours/ns, 86.360 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.375     | 11.375     | 11.375     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040355   | 0.040355   | 0.040355   |   0.0 |  0.35
Output  | 8.8873e-05 | 8.8873e-05 | 8.8873e-05 |   0.0 |  0.00
Modify  | 0.14252    | 0.14252    | 0.14252    |   0.0 |  1.23
Other   |            | 0.02146    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276924.0 ave      276924 max      276924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276924
Ave neighs/atom = 138.46200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.440249781504, Press = 0.0601193579667769
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  192000   -7880.0667   -7880.0667   -7953.7621   -7953.7621    285.20891    285.20891    23395.236    23395.236   -1277.8417   -1277.8417 
  193000   -7874.7022   -7874.7022   -7950.1007   -7950.1007    291.79982    291.79982    23401.862    23401.862   -1317.5951   -1317.5951 
Loop time of 11.5721 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.466 ns/day, 3.214 hours/ns, 86.415 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.368     | 11.368     | 11.368     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040308   | 0.040308   | 0.040308   |   0.0 |  0.35
Output  | 6.1946e-05 | 6.1946e-05 | 6.1946e-05 |   0.0 |  0.00
Modify  | 0.14204    | 0.14204    | 0.14204    |   0.0 |  1.23
Other   |            | 0.02154    |            |       |  0.19

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

Total # of neighbors = 276822
Ave neighs/atom = 138.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 = 293.433069991861, Press = 0.356779473751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  193000   -7874.7022   -7874.7022   -7950.1007   -7950.1007    291.79982    291.79982    23401.862    23401.862   -1317.5951   -1317.5951 
  194000   -7878.9851   -7878.9851   -7954.1356   -7954.1356     290.8403     290.8403    23387.306    23387.306   -910.67615   -910.67615 
Loop time of 11.5176 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.502 ns/day, 3.199 hours/ns, 86.824 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.316     | 11.316     | 11.316     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039965   | 0.039965   | 0.039965   |   0.0 |  0.35
Output  | 8.3916e-05 | 8.3916e-05 | 8.3916e-05 |   0.0 |  0.00
Modify  | 0.14063    | 0.14063    | 0.14063    |   0.0 |  1.22
Other   |            | 0.02095    |            |       |  0.18

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

Total # of neighbors = 276960
Ave neighs/atom = 138.48000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.41648920439, Press = 0.41159603057008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  194000   -7878.9851   -7878.9851   -7954.1356   -7954.1356     290.8403     290.8403    23387.306    23387.306   -910.67615   -910.67615 
  195000    -7872.806    -7872.806   -7949.4653   -7949.4653    296.67948    296.67948    23361.506    23361.506    1529.1009    1529.1009 
Loop time of 11.7583 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.348 ns/day, 3.266 hours/ns, 85.046 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.547     | 11.547     | 11.547     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041476   | 0.041476   | 0.041476   |   0.0 |  0.35
Output  | 8.4916e-05 | 8.4916e-05 | 8.4916e-05 |   0.0 |  0.00
Modify  | 0.14741    | 0.14741    | 0.14741    |   0.0 |  1.25
Other   |            | 0.02207    |            |       |  0.19

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

Total # of neighbors = 276808
Ave neighs/atom = 138.40400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.416290233256, Press = 0.417778081669941
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  195000    -7872.806    -7872.806   -7949.4653   -7949.4653    296.67948    296.67948    23361.506    23361.506    1529.1009    1529.1009 
  196000   -7874.7124   -7874.7124   -7952.6392   -7952.6392    301.58443    301.58443    23339.392    23339.392    2735.9145    2735.9145 
Loop time of 11.6217 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.434 ns/day, 3.228 hours/ns, 86.046 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.415     | 11.415     | 11.415     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040543   | 0.040543   | 0.040543   |   0.0 |  0.35
Output  | 8.4852e-05 | 8.4852e-05 | 8.4852e-05 |   0.0 |  0.00
Modify  | 0.14401    | 0.14401    | 0.14401    |   0.0 |  1.24
Other   |            | 0.02192    |            |       |  0.19

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

Total # of neighbors = 277330
Ave neighs/atom = 138.66500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.406433849901, Press = 0.246471649563348
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  196000   -7874.7124   -7874.7124   -7952.6392   -7952.6392    301.58443    301.58443    23339.392    23339.392    2735.9145    2735.9145 
  197000   -7878.2623   -7878.2623   -7952.4472   -7952.4472    287.10314    287.10314    23336.083    23336.083    2964.1146    2964.1146 
Loop time of 11.5314 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.493 ns/day, 3.203 hours/ns, 86.720 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.329     | 11.329     | 11.329     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040003   | 0.040003   | 0.040003   |   0.0 |  0.35
Output  | 0.00021284 | 0.00021284 | 0.00021284 |   0.0 |  0.00
Modify  | 0.14098    | 0.14098    | 0.14098    |   0.0 |  1.22
Other   |            | 0.02132    |            |       |  0.18

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

Total # of neighbors = 277740
Ave neighs/atom = 138.87000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.399841739243, Press = -0.0578033990903749
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  197000   -7878.2623   -7878.2623   -7952.4472   -7952.4472    287.10314    287.10314    23336.083    23336.083    2964.1146    2964.1146 
  198000   -7874.5892   -7874.5892   -7950.6931   -7950.6931    294.52994    294.52994    23362.162    23362.162    1226.9484    1226.9484 
Loop time of 11.6097 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.442 ns/day, 3.225 hours/ns, 86.135 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.404     | 11.404     | 11.404     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040385   | 0.040385   | 0.040385   |   0.0 |  0.35
Output  | 8.5813e-05 | 8.5813e-05 | 8.5813e-05 |   0.0 |  0.00
Modify  | 0.14355    | 0.14355    | 0.14355    |   0.0 |  1.24
Other   |            | 0.02144    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277450.0 ave      277450 max      277450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277450
Ave neighs/atom = 138.72500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.382089594284, Press = -0.239447098760912
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  198000   -7874.5892   -7874.5892   -7950.6931   -7950.6931    294.52994    294.52994    23362.162    23362.162    1226.9484    1226.9484 
  199000   -7877.8258   -7877.8258   -7952.2504   -7952.2504    288.03084    288.03084    23384.402    23384.402   -414.48577   -414.48577 
Loop time of 11.5876 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.456 ns/day, 3.219 hours/ns, 86.299 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.383     | 11.383     | 11.383     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04043    | 0.04043    | 0.04043    |   0.0 |  0.35
Output  | 9.7731e-05 | 9.7731e-05 | 9.7731e-05 |   0.0 |  0.00
Modify  | 0.14296    | 0.14296    | 0.14296    |   0.0 |  1.23
Other   |            | 0.02153    |            |       |  0.19

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

Total # of neighbors = 277460
Ave neighs/atom = 138.73000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.37921030061, Press = -0.182376546717998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  199000   -7877.8258   -7877.8258   -7952.2504   -7952.2504    288.03084    288.03084    23384.402    23384.402   -414.48577   -414.48577 
  200000   -7874.8865   -7874.8865   -7949.5961   -7949.5961    289.13385    289.13385    23395.017    23395.017   -738.43585   -738.43585 
Loop time of 11.5288 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.494 ns/day, 3.202 hours/ns, 86.739 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.326     | 11.326     | 11.326     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04012    | 0.04012    | 0.04012    |   0.0 |  0.35
Output  | 8.7184e-05 | 8.7184e-05 | 8.7184e-05 |   0.0 |  0.00
Modify  | 0.14109    | 0.14109    | 0.14109    |   0.0 |  1.22
Other   |            | 0.02112    |            |       |  0.18

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

Total # of neighbors = 277042
Ave neighs/atom = 138.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 = 293.377598654748, Press = -0.146127777020003
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  200000   -7874.8865   -7874.8865   -7949.5961   -7949.5961    289.13385    289.13385    23395.017    23395.017   -738.43585   -738.43585 
  201000   -7874.7737   -7874.7737   -7950.9904   -7950.9904    294.96669    294.96669    23407.114    23407.114   -1973.7671   -1973.7671 
Loop time of 11.5302 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.493 ns/day, 3.203 hours/ns, 86.729 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.328     | 11.328     | 11.328     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040169   | 0.040169   | 0.040169   |   0.0 |  0.35
Output  | 8.2387e-05 | 8.2387e-05 | 8.2387e-05 |   0.0 |  0.00
Modify  | 0.14054    | 0.14054    | 0.14054    |   0.0 |  1.22
Other   |            | 0.02113    |            |       |  0.18

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

Total # of neighbors = 277058
Ave neighs/atom = 138.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 = 293.379471740526, Press = -0.133751205037871
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  201000   -7874.7737   -7874.7737   -7950.9904   -7950.9904    294.96669    294.96669    23407.114    23407.114   -1973.7671   -1973.7671 
  202000   -7876.4038   -7876.4038   -7951.2233   -7951.2233     289.5592     289.5592    23403.435    23403.435   -1230.0154   -1230.0154 
Loop time of 11.6103 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.442 ns/day, 3.225 hours/ns, 86.130 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.404     | 11.404     | 11.404     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040718   | 0.040718   | 0.040718   |   0.0 |  0.35
Output  | 6.1515e-05 | 6.1515e-05 | 6.1515e-05 |   0.0 |  0.00
Modify  | 0.14377    | 0.14377    | 0.14377    |   0.0 |  1.24
Other   |            | 0.02174    |            |       |  0.19

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

Total # of neighbors = 276894
Ave neighs/atom = 138.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 = 293.378115616046, Press = 0.21546658055525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  202000   -7876.4038   -7876.4038   -7951.2233   -7951.2233     289.5592     289.5592    23403.435    23403.435   -1230.0154   -1230.0154 
  203000   -7874.1815   -7874.1815   -7950.7295   -7950.7295    296.24869    296.24869     23387.64     23387.64   -449.77182   -449.77182 
Loop time of 11.5189 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.501 ns/day, 3.200 hours/ns, 86.814 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.317     | 11.317     | 11.317     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040114   | 0.040114   | 0.040114   |   0.0 |  0.35
Output  | 6.9964e-05 | 6.9964e-05 | 6.9964e-05 |   0.0 |  0.00
Modify  | 0.14064    | 0.14064    | 0.14064    |   0.0 |  1.22
Other   |            | 0.0209     |            |       |  0.18

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

Total # of neighbors = 276882
Ave neighs/atom = 138.44100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.375088786957, Press = 0.253458946639646
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  203000   -7874.1815   -7874.1815   -7950.7295   -7950.7295    296.24869    296.24869     23387.64     23387.64   -449.77182   -449.77182 
  204000   -7873.7939   -7873.7939   -7950.0451   -7950.0451    295.10029    295.10029    23382.013    23382.013    189.70395    189.70395 
Loop time of 11.5401 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.487 ns/day, 3.206 hours/ns, 86.655 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.337     | 11.337     | 11.337     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040162   | 0.040162   | 0.040162   |   0.0 |  0.35
Output  | 6.661e-05  | 6.661e-05  | 6.661e-05  |   0.0 |  0.00
Modify  | 0.14153    | 0.14153    | 0.14153    |   0.0 |  1.23
Other   |            | 0.0215     |            |       |  0.19

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

Total # of neighbors = 277090
Ave neighs/atom = 138.54500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.37796507, Press = 0.246443020803807
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  204000   -7873.7939   -7873.7939   -7950.0451   -7950.0451    295.10029    295.10029    23382.013    23382.013    189.70395    189.70395 
  205000   -7879.6842   -7879.6842   -7952.6439   -7952.6439    282.36176    282.36176    23370.626    23370.626     451.9286     451.9286 
Loop time of 11.6866 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.393 ns/day, 3.246 hours/ns, 85.568 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.48      | 11.48      | 11.48      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040942   | 0.040942   | 0.040942   |   0.0 |  0.35
Output  | 6.1296e-05 | 6.1296e-05 | 6.1296e-05 |   0.0 |  0.00
Modify  | 0.14436    | 0.14436    | 0.14436    |   0.0 |  1.24
Other   |            | 0.02151    |            |       |  0.18

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

Total # of neighbors = 277338
Ave neighs/atom = 138.66900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.369628874448, Press = 0.403751870303106
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  205000   -7879.6842   -7879.6842   -7952.6439   -7952.6439    282.36176    282.36176    23370.626    23370.626     451.9286     451.9286 
  206000   -7874.1834   -7874.1834   -7953.0853   -7953.0853    305.35853    305.35853    23355.443    23355.443    1628.0036    1628.0036 
Loop time of 11.5978 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.450 ns/day, 3.222 hours/ns, 86.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    | 11.392     | 11.392     | 11.392     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040582   | 0.040582   | 0.040582   |   0.0 |  0.35
Output  | 8.401e-05  | 8.401e-05  | 8.401e-05  |   0.0 |  0.00
Modify  | 0.14299    | 0.14299    | 0.14299    |   0.0 |  1.23
Other   |            | 0.02227    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5462.00 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277384.0 ave      277384 max      277384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277384
Ave neighs/atom = 138.69200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.359479822374, Press = 0.484411982835516
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  206000   -7874.1834   -7874.1834   -7953.0853   -7953.0853    305.35853    305.35853    23355.443    23355.443    1628.0036    1628.0036 
  207000   -7878.2117   -7878.2117   -7951.8168   -7951.8168    284.85913    284.85913    23311.989    23311.989    4555.9233    4555.9233 
Loop time of 11.556 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.477 ns/day, 3.210 hours/ns, 86.535 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.353     | 11.353     | 11.353     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040308   | 0.040308   | 0.040308   |   0.0 |  0.35
Output  | 7.7076e-05 | 7.7076e-05 | 7.7076e-05 |   0.0 |  0.00
Modify  | 0.1413     | 0.1413     | 0.1413     |   0.0 |  1.22
Other   |            | 0.02152    |            |       |  0.19

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

Total # of neighbors = 277440
Ave neighs/atom = 138.72000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.346755805186, Press = 0.519785248106208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  207000   -7878.2117   -7878.2117   -7951.8168   -7951.8168    284.85913    284.85913    23311.989    23311.989    4555.9233    4555.9233 
  208000   -7874.0464   -7874.0464   -7950.7566   -7950.7566    296.87637    296.87637     23360.75     23360.75    1364.3648    1364.3648 
Loop time of 11.5652 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.471 ns/day, 3.213 hours/ns, 86.466 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.363     | 11.363     | 11.363     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040259   | 0.040259   | 0.040259   |   0.0 |  0.35
Output  | 8.2803e-05 | 8.2803e-05 | 8.2803e-05 |   0.0 |  0.00
Modify  | 0.14111    | 0.14111    | 0.14111    |   0.0 |  1.22
Other   |            | 0.02114    |            |       |  0.18

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

Total # of neighbors = 277982
Ave neighs/atom = 138.99100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.334264303859, Press = 0.265334419645476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  208000   -7874.0464   -7874.0464   -7950.7566   -7950.7566    296.87637    296.87637     23360.75     23360.75    1364.3648    1364.3648 
  209000    -7879.298    -7879.298   -7952.4893   -7952.4893    283.25783    283.25783      23373.6      23373.6    415.24997    415.24997 
Loop time of 11.5196 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.500 ns/day, 3.200 hours/ns, 86.808 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.318     | 11.318     | 11.318     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040273   | 0.040273   | 0.040273   |   0.0 |  0.35
Output  | 8.8335e-05 | 8.8335e-05 | 8.8335e-05 |   0.0 |  0.00
Modify  | 0.14054    | 0.14054    | 0.14054    |   0.0 |  1.22
Other   |            | 0.02102    |            |       |  0.18

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

Total # of neighbors = 277444
Ave neighs/atom = 138.72200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.324101990177, Press = 0.35100844316418
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  209000    -7879.298    -7879.298   -7952.4893   -7952.4893    283.25783    283.25783      23373.6      23373.6    415.24997    415.24997 
  210000   -7875.4382   -7875.4382   -7951.3568   -7951.3568    293.81254    293.81254     23378.81     23378.81     121.3945     121.3945 
Loop time of 11.551 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.480 ns/day, 3.209 hours/ns, 86.572 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.349     | 11.349     | 11.349     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040309   | 0.040309   | 0.040309   |   0.0 |  0.35
Output  | 0.00013117 | 0.00013117 | 0.00013117 |   0.0 |  0.00
Modify  | 0.14063    | 0.14063    | 0.14063    |   0.0 |  1.22
Other   |            | 0.02127    |            |       |  0.18

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

Total # of neighbors = 277104
Ave neighs/atom = 138.55200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.316222180035, Press = 0.28643720862308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  210000   -7875.4382   -7875.4382   -7951.3568   -7951.3568    293.81254    293.81254     23378.81     23378.81     121.3945     121.3945 
  211000   -7875.0771   -7875.0771   -7951.7112   -7951.7112    296.58164    296.58164     23379.48     23379.48     381.1011     381.1011 
Loop time of 11.5863 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.457 ns/day, 3.218 hours/ns, 86.309 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.382     | 11.382     | 11.382     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040386   | 0.040386   | 0.040386   |   0.0 |  0.35
Output  | 9.3267e-05 | 9.3267e-05 | 9.3267e-05 |   0.0 |  0.00
Modify  | 0.14191    | 0.14191    | 0.14191    |   0.0 |  1.22
Other   |            | 0.02141    |            |       |  0.18

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

Total # of neighbors = 277270
Ave neighs/atom = 138.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 = 293.312064842656, Press = 0.510157552023025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  211000   -7875.0771   -7875.0771   -7951.7112   -7951.7112    296.58164    296.58164     23379.48     23379.48     381.1011     381.1011 
  212000   -7873.8902   -7873.8902   -7949.9508   -7949.9508    294.36216    294.36216    23360.131    23360.131    1705.6854    1705.6854 
Loop time of 11.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.468 ns/day, 3.214 hours/ns, 86.438 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.366     | 11.366     | 11.366     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04036    | 0.04036    | 0.04036    |   0.0 |  0.35
Output  | 0.00014502 | 0.00014502 | 0.00014502 |   0.0 |  0.00
Modify  | 0.14159    | 0.14159    | 0.14159    |   0.0 |  1.22
Other   |            | 0.02131    |            |       |  0.18

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

Total # of neighbors = 277020
Ave neighs/atom = 138.51000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.327073736414, Press = 0.713496598311116
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  212000   -7873.8902   -7873.8902   -7949.9508   -7949.9508    294.36216    294.36216    23360.131    23360.131    1705.6854    1705.6854 
  213000   -7876.1051   -7876.1051   -7951.7512   -7951.7512    292.75834    292.75834    23360.545    23360.545    1262.8064    1262.8064 
Loop time of 11.5095 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.507 ns/day, 3.197 hours/ns, 86.885 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.308     | 11.308     | 11.308     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04008    | 0.04008    | 0.04008    |   0.0 |  0.35
Output  | 7.9719e-05 | 7.9719e-05 | 7.9719e-05 |   0.0 |  0.00
Modify  | 0.13997    | 0.13997    | 0.13997    |   0.0 |  1.22
Other   |            | 0.02103    |            |       |  0.18

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

Total # of neighbors = 277610
Ave neighs/atom = 138.80500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.334330189198, Press = 0.354858587013551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  213000   -7876.1051   -7876.1051   -7951.7512   -7951.7512    292.75834    292.75834    23360.545    23360.545    1262.8064    1262.8064 
  214000   -7870.6206   -7870.6206   -7948.2368   -7948.2368    300.38296    300.38296    23362.329    23362.329    1655.4861    1655.4861 
Loop time of 11.5915 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.454 ns/day, 3.220 hours/ns, 86.270 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.387     | 11.387     | 11.387     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040669   | 0.040669   | 0.040669   |   0.0 |  0.35
Output  | 0.00012707 | 0.00012707 | 0.00012707 |   0.0 |  0.00
Modify  | 0.14215    | 0.14215    | 0.14215    |   0.0 |  1.23
Other   |            | 0.02132    |            |       |  0.18

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

Total # of neighbors = 277266
Ave neighs/atom = 138.63300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.344456401228, Press = 0.261742077384683
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  214000   -7870.6206   -7870.6206   -7948.2368   -7948.2368    300.38296    300.38296    23362.329    23362.329    1655.4861    1655.4861 
  215000   -7875.1069   -7875.1069   -7951.7074   -7951.7074    296.45191    296.45191    23362.042    23362.042    1396.7013    1396.7013 
Loop time of 11.5938 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.452 ns/day, 3.220 hours/ns, 86.253 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.39      | 11.39      | 11.39      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0405     | 0.0405     | 0.0405     |   0.0 |  0.35
Output  | 9.2115e-05 | 9.2115e-05 | 9.2115e-05 |   0.0 |  0.00
Modify  | 0.1421     | 0.1421     | 0.1421     |   0.0 |  1.23
Other   |            | 0.02128    |            |       |  0.18

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

Total # of neighbors = 277724
Ave neighs/atom = 138.86200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
23383.5466439215

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0