# 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.8809780403971668*${_u_distance}
variable latticeconst_converted equal 2.8809780403971668*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097804039717
Lattice spacing in x,y,z = 2.880978 2.880978 2.880978
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.80978 28.80978 28.80978)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (28.80978 28.80978 28.80978)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ChoiJoSohn_2018_CoNiCrFeMn__MO_115454747503_002
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23912.2170404509 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_115454747503_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8113.917      -8113.917      -8200          -8200           333.15         333.15         23912.217      23912.217      3845.1549      3845.1549    
      1000  -8023.5714     -8023.5714     -8112.0891     -8112.0891      342.57266      342.57266      24162.447      24162.447      2790.3881      2790.3881    
Loop time of 151.014 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.948 hours/ns, 6.622 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.51     | 150.51     | 150.51     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097604   | 0.097604   | 0.097604   |   0.0 |  0.06
Output  | 0.00020672 | 0.00020672 | 0.00020672 |   0.0 |  0.00
Modify  | 0.34986    | 0.34986    | 0.34986    |   0.0 |  0.23
Other   |            | 0.05983    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       224000 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8023.5714     -8023.5714     -8112.0891     -8112.0891      342.57266      342.57266      24162.447      24162.447      2790.3881      2790.3881    
      2000  -8023.8531     -8023.8531     -8113.0504     -8113.0504      345.20271      345.20271      24192.445      24192.445      155.06883      155.06883    
Loop time of 148.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.158 hours/ns, 6.749 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.66     | 147.66     | 147.66     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096058   | 0.096058   | 0.096058   |   0.0 |  0.06
Output  | 0.00020598 | 0.00020598 | 0.00020598 |   0.0 |  0.00
Modify  | 0.35204    | 0.35204    | 0.35204    |   0.0 |  0.24
Other   |            | 0.06055    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206862 ave      206862 max      206862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206862
Ave neighs/atom = 103.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8023.8531     -8023.8531     -8113.0504     -8113.0504      345.20271      345.20271      24192.445      24192.445      155.06883      155.06883    
      3000  -8025.8952     -8025.8952     -8111.9021     -8111.9021      332.85533      332.85533      24212.878      24212.878     -1420.653      -1420.653     
Loop time of 150.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.862 hours/ns, 6.636 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.18     | 150.18     | 150.18     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097766   | 0.097766   | 0.097766   |   0.0 |  0.06
Output  | 0.0002071  | 0.0002071  | 0.0002071  |   0.0 |  0.00
Modify  | 0.35847    | 0.35847    | 0.35847    |   0.0 |  0.24
Other   |            | 0.06079    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206298 ave      206298 max      206298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206298
Ave neighs/atom = 103.149
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8025.8952     -8025.8952     -8111.9021     -8111.9021      332.85533      332.85533      24212.878      24212.878     -1420.653      -1420.653     
      4000  -8022.7041     -8022.7041     -8112.6078     -8112.6078      347.93659      347.93659      24226.14       24226.14      -2685.5725     -2685.5725    
Loop time of 149.318 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.477 hours/ns, 6.697 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.81     | 148.81     | 148.81     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097109   | 0.097109   | 0.097109   |   0.0 |  0.07
Output  | 0.00020478 | 0.00020478 | 0.00020478 |   0.0 |  0.00
Modify  | 0.35454    | 0.35454    | 0.35454    |   0.0 |  0.24
Other   |            | 0.06068    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205476 ave      205476 max      205476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205476
Ave neighs/atom = 102.738
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8022.7041     -8022.7041     -8112.6078     -8112.6078      347.93659      347.93659      24226.14       24226.14      -2685.5725     -2685.5725    
      5000  -8027.2273     -8027.2273     -8110.5049     -8110.5049      322.29281      322.29281      24208.564      24208.564     -861.00104     -861.00104    
Loop time of 151.457 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.071 hours/ns, 6.603 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.93     | 150.93     | 150.93     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098194   | 0.098194   | 0.098194   |   0.0 |  0.06
Output  | 0.00016396 | 0.00016396 | 0.00016396 |   0.0 |  0.00
Modify  | 0.36363    | 0.36363    | 0.36363    |   0.0 |  0.24
Other   |            | 0.06133    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205474 ave      205474 max      205474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205474
Ave neighs/atom = 102.737
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 330.859379824334, Press = -333.405598407877
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8027.2273     -8027.2273     -8110.5049     -8110.5049      322.29281      322.29281      24208.564      24208.564     -861.00104     -861.00104    
      6000  -8023.515      -8023.515      -8109.6508     -8109.6508      333.35443      333.35443      24204.848      24204.848     -547.02935     -547.02935    
Loop time of 152.562 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.378 hours/ns, 6.555 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.02     | 152.02     | 152.02     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098313   | 0.098313   | 0.098313   |   0.0 |  0.06
Output  | 0.00021415 | 0.00021415 | 0.00021415 |   0.0 |  0.00
Modify  | 0.38367    | 0.38367    | 0.38367    |   0.0 |  0.25
Other   |            | 0.06084    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205762 ave      205762 max      205762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205762
Ave neighs/atom = 102.881
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.577523547257, Press = -50.1639406995531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8023.515      -8023.515      -8109.6508     -8109.6508      333.35443      333.35443      24204.848      24204.848     -547.02935     -547.02935    
      7000  -8026.001      -8026.001      -8109.2692     -8109.2692      322.25658      322.25658      24168.219      24168.219      2302.7954      2302.7954    
Loop time of 152.001 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.223 hours/ns, 6.579 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.45     | 151.45     | 151.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098767   | 0.098767   | 0.098767   |   0.0 |  0.06
Output  | 0.00017647 | 0.00017647 | 0.00017647 |   0.0 |  0.00
Modify  | 0.38622    | 0.38622    | 0.38622    |   0.0 |  0.25
Other   |            | 0.06135    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205704 ave      205704 max      205704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205704
Ave neighs/atom = 102.852
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.191085032519, Press = -30.3390396373526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8026.001      -8026.001      -8109.2692     -8109.2692      322.25658      322.25658      24168.219      24168.219      2302.7954      2302.7954    
      8000  -8017.5659     -8017.5659     -8109.5193     -8109.5193      355.86921      355.86921      24153.293      24153.293      3911.8682      3911.8682    
Loop time of 151.976 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.216 hours/ns, 6.580 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.43     | 151.43     | 151.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098244   | 0.098244   | 0.098244   |   0.0 |  0.06
Output  | 0.00016143 | 0.00016143 | 0.00016143 |   0.0 |  0.00
Modify  | 0.38249    | 0.38249    | 0.38249    |   0.0 |  0.25
Other   |            | 0.06117    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206448 ave      206448 max      206448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206448
Ave neighs/atom = 103.224
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.23806889727, Press = -2.80932282430477
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8017.5659     -8017.5659     -8109.5193     -8109.5193      355.86921      355.86921      24153.293      24153.293      3911.8682      3911.8682    
      9000  -8026.1711     -8026.1711     -8112.2053     -8112.2053      332.9613       332.9613       24153.577      24153.577      3112.2476      3112.2476    
Loop time of 152.925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.479 hours/ns, 6.539 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.38     | 152.38     | 152.38     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099356   | 0.099356   | 0.099356   |   0.0 |  0.06
Output  | 0.00020017 | 0.00020017 | 0.00020017 |   0.0 |  0.00
Modify  | 0.38669    | 0.38669    | 0.38669    |   0.0 |  0.25
Other   |            | 0.06106    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206496 ave      206496 max      206496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206496
Ave neighs/atom = 103.248
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.901014290793, Press = 11.6102393871772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8026.1711     -8026.1711     -8112.2053     -8112.2053      332.9613       332.9613       24153.577      24153.577      3112.2476      3112.2476    
     10000  -8021.899      -8021.899      -8112.1422     -8112.1422      349.25044      349.25044      24198.789      24198.789     -317.94938     -317.94938    
Loop time of 150.813 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.892 hours/ns, 6.631 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.27     | 150.27     | 150.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09754    | 0.09754    | 0.09754    |   0.0 |  0.06
Output  | 0.0001637  | 0.0001637  | 0.0001637  |   0.0 |  0.00
Modify  | 0.37995    | 0.37995    | 0.37995    |   0.0 |  0.25
Other   |            | 0.0611     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207068 ave      207068 max      207068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207068
Ave neighs/atom = 103.534
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.146618388866, Press = 7.50384811389227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8021.899      -8021.899      -8112.1422     -8112.1422      349.25044      349.25044      24198.789      24198.789     -317.94938     -317.94938    
     11000  -8026.4471     -8026.4471     -8111.4217     -8111.4217      328.86064      328.86064      24195.631      24195.631     -108.74499     -108.74499    
Loop time of 151.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.979 hours/ns, 6.617 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.58     | 150.58     | 150.58     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098329   | 0.098329   | 0.098329   |   0.0 |  0.07
Output  | 0.00016494 | 0.00016494 | 0.00016494 |   0.0 |  0.00
Modify  | 0.3831     | 0.3831     | 0.3831     |   0.0 |  0.25
Other   |            | 0.06107    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205888 ave      205888 max      205888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205888
Ave neighs/atom = 102.944
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.122779918132, Press = 2.96968784049721
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8026.4471     -8026.4471     -8111.4217     -8111.4217      328.86064      328.86064      24195.631      24195.631     -108.74499     -108.74499    
     12000  -8024.6047     -8024.6047     -8113.2645     -8113.2645      343.12252      343.12252      24220.802      24220.802     -2472.3379     -2472.3379    
Loop time of 150.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.714 hours/ns, 6.659 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.63     | 149.63     | 149.63     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097863   | 0.097863   | 0.097863   |   0.0 |  0.07
Output  | 0.0001644  | 0.0001644  | 0.0001644  |   0.0 |  0.00
Modify  | 0.37639    | 0.37639    | 0.37639    |   0.0 |  0.25
Other   |            | 0.06064    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205928 ave      205928 max      205928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205928
Ave neighs/atom = 102.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.239068875528, Press = 0.136527542427027
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8024.6047     -8024.6047     -8113.2645     -8113.2645      343.12252      343.12252      24220.802      24220.802     -2472.3379     -2472.3379    
     13000  -8023.4386     -8023.4386     -8107.3232     -8107.3232      324.6419       324.6419       24230.067      24230.067     -2129.6472     -2129.6472    
Loop time of 149.234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.454 hours/ns, 6.701 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.7      | 148.7      | 148.7      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096767   | 0.096767   | 0.096767   |   0.0 |  0.06
Output  | 0.00020075 | 0.00020075 | 0.00020075 |   0.0 |  0.00
Modify  | 0.37515    | 0.37515    | 0.37515    |   0.0 |  0.25
Other   |            | 0.0607     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205728 ave      205728 max      205728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205728
Ave neighs/atom = 102.864
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.246118581448, Press = -4.96859293207737
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8023.4386     -8023.4386     -8107.3232     -8107.3232      324.6419       324.6419       24230.067      24230.067     -2129.6472     -2129.6472    
     14000  -8024.2141     -8024.2141     -8112.269      -8112.269       340.78162      340.78162      24217.723      24217.723     -1858.8958     -1858.8958    
Loop time of 149.322 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.478 hours/ns, 6.697 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.79     | 148.79     | 148.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097145   | 0.097145   | 0.097145   |   0.0 |  0.07
Output  | 0.00016235 | 0.00016235 | 0.00016235 |   0.0 |  0.00
Modify  | 0.377      | 0.377      | 0.377      |   0.0 |  0.25
Other   |            | 0.06075    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204898 ave      204898 max      204898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204898
Ave neighs/atom = 102.449
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.49369496249, Press = -11.4232469526765
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8024.2141     -8024.2141     -8112.269      -8112.269       340.78162      340.78162      24217.723      24217.723     -1858.8958     -1858.8958    
     15000  -8022.626      -8022.626      -8108.613      -8108.613       332.77832      332.77832      24187.333      24187.333      1150.5542      1150.5542    
Loop time of 149.52 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.533 hours/ns, 6.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.99     | 148.99     | 148.99     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097111   | 0.097111   | 0.097111   |   0.0 |  0.06
Output  | 0.00016343 | 0.00016343 | 0.00016343 |   0.0 |  0.00
Modify  | 0.37317    | 0.37317    | 0.37317    |   0.0 |  0.25
Other   |            | 0.06086    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205820 ave      205820 max      205820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205820
Ave neighs/atom = 102.91
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.424678433055, Press = -7.41029207615254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8022.626      -8022.626      -8108.613      -8108.613       332.77832      332.77832      24187.333      24187.333      1150.5542      1150.5542    
     16000  -8024.0226     -8024.0226     -8111.9499     -8111.9499      340.2878       340.2878       24168.534      24168.534      2111.2179      2111.2179    
Loop time of 150.085 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.690 hours/ns, 6.663 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.55     | 149.55     | 149.55     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097745   | 0.097745   | 0.097745   |   0.0 |  0.07
Output  | 0.00020414 | 0.00020414 | 0.00020414 |   0.0 |  0.00
Modify  | 0.37547    | 0.37547    | 0.37547    |   0.0 |  0.25
Other   |            | 0.06074    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206082 ave      206082 max      206082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206082
Ave neighs/atom = 103.041
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.546793046539, Press = -1.23655432053103
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8024.0226     -8024.0226     -8111.9499     -8111.9499      340.2878       340.2878       24168.534      24168.534      2111.2179      2111.2179    
     17000  -8025.2689     -8025.2689     -8109.8357     -8109.8357      327.28212      327.28212      24165.732      24165.732      2672.8789      2672.8789    
Loop time of 150.386 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.774 hours/ns, 6.650 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.85     | 149.85     | 149.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097508   | 0.097508   | 0.097508   |   0.0 |  0.06
Output  | 0.00016682 | 0.00016682 | 0.00016682 |   0.0 |  0.00
Modify  | 0.37869    | 0.37869    | 0.37869    |   0.0 |  0.25
Other   |            | 0.06105    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206434 ave      206434 max      206434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206434
Ave neighs/atom = 103.217
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.357156782011, Press = 1.49554033103025
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8025.2689     -8025.2689     -8109.8357     -8109.8357      327.28212      327.28212      24165.732      24165.732      2672.8789      2672.8789    
     18000  -8028.8288     -8028.8288     -8113.3448     -8113.3448      327.08551      327.08551      24168.576      24168.576      1643.8758      1643.8758    
Loop time of 151.076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.966 hours/ns, 6.619 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.54     | 150.54     | 150.54     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098338   | 0.098338   | 0.098338   |   0.0 |  0.07
Output  | 0.00020969 | 0.00020969 | 0.00020969 |   0.0 |  0.00
Modify  | 0.38142    | 0.38142    | 0.38142    |   0.0 |  0.25
Other   |            | 0.0608     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206620 ave      206620 max      206620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206620
Ave neighs/atom = 103.31
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.137212350134, Press = 3.73798618901188
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8028.8288     -8028.8288     -8113.3448     -8113.3448      327.08551      327.08551      24168.576      24168.576      1643.8758      1643.8758    
     19000  -8024.23       -8024.23       -8109.7949     -8109.7949      331.14506      331.14506      24197.674      24197.674      427.24249      427.24249    
Loop time of 149.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.654 hours/ns, 6.669 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.42     | 149.42     | 149.42     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097954   | 0.097954   | 0.097954   |   0.0 |  0.07
Output  | 0.00016671 | 0.00016671 | 0.00016671 |   0.0 |  0.00
Modify  | 0.37632    | 0.37632    | 0.37632    |   0.0 |  0.25
Other   |            | 0.06109    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206692 ave      206692 max      206692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206692
Ave neighs/atom = 103.346
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.972216262177, Press = 7.30574431457086
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8024.23       -8024.23       -8109.7949     -8109.7949      331.14506      331.14506      24197.674      24197.674      427.24249      427.24249    
     20000  -8027.709      -8027.709      -8110.1482     -8110.1482      319.04829      319.04829      24242.035      24242.035     -3708.2754     -3708.2754    
Loop time of 150.049 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.680 hours/ns, 6.665 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.51     | 149.51     | 149.51     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096944   | 0.096944   | 0.096944   |   0.0 |  0.06
Output  | 0.00016582 | 0.00016582 | 0.00016582 |   0.0 |  0.00
Modify  | 0.37714    | 0.37714    | 0.37714    |   0.0 |  0.25
Other   |            | 0.06079    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205872 ave      205872 max      205872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205872
Ave neighs/atom = 102.936
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.966062732733, Press = 5.05894616253056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8027.709      -8027.709      -8110.1482     -8110.1482      319.04829      319.04829      24242.035      24242.035     -3708.2754     -3708.2754    
     21000  -8024.6121     -8024.6121     -8109.411      -8109.411       328.1808       328.1808       24223.131      24223.131     -1659.7473     -1659.7473    
Loop time of 148.528 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.258 hours/ns, 6.733 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148        | 148        | 148        |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097237   | 0.097237   | 0.097237   |   0.0 |  0.07
Output  | 0.00016672 | 0.00016672 | 0.00016672 |   0.0 |  0.00
Modify  | 0.37412    | 0.37412    | 0.37412    |   0.0 |  0.25
Other   |            | 0.06086    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205144 ave      205144 max      205144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205144
Ave neighs/atom = 102.572
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.882854445111, Press = -0.624433784171977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8024.6121     -8024.6121     -8109.411      -8109.411       328.1808       328.1808       24223.131      24223.131     -1659.7473     -1659.7473    
     22000  -8025.0564     -8025.0564     -8110.3126     -8110.3126      329.95037      329.95037      24201.738      24201.738     -44.863562     -44.863562    
Loop time of 150.207 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.724 hours/ns, 6.657 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.67     | 149.67     | 149.67     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097314   | 0.097314   | 0.097314   |   0.0 |  0.06
Output  | 0.00020153 | 0.00020153 | 0.00020153 |   0.0 |  0.00
Modify  | 0.37946    | 0.37946    | 0.37946    |   0.0 |  0.25
Other   |            | 0.0609     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205658 ave      205658 max      205658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205658
Ave neighs/atom = 102.829
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.644195348642, Press = -1.33471144964655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8025.0564     -8025.0564     -8110.3126     -8110.3126      329.95037      329.95037      24201.738      24201.738     -44.863562     -44.863562    
     23000  -8025.535      -8025.535      -8112.1129     -8112.1129      335.0653       335.0653       24182.649      24182.649      756.37855      756.37855    
Loop time of 150.118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.699 hours/ns, 6.661 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.58     | 149.58     | 149.58     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096762   | 0.096762   | 0.096762   |   0.0 |  0.06
Output  | 0.00016448 | 0.00016448 | 0.00016448 |   0.0 |  0.00
Modify  | 0.37755    | 0.37755    | 0.37755    |   0.0 |  0.25
Other   |            | 0.06111    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205792 ave      205792 max      205792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205792
Ave neighs/atom = 102.896
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.538429031522, Press = -0.871199841445569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8025.535      -8025.535      -8112.1129     -8112.1129      335.0653       335.0653       24182.649      24182.649      756.37855      756.37855    
     24000  -8025.1161     -8025.1161     -8110.5818     -8110.5818      330.76105      330.76105      24168.872      24168.872      2296.845       2296.845     
Loop time of 149.539 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.539 hours/ns, 6.687 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.01     | 149.01     | 149.01     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097307   | 0.097307   | 0.097307   |   0.0 |  0.07
Output  | 0.00016478 | 0.00016478 | 0.00016478 |   0.0 |  0.00
Modify  | 0.37533    | 0.37533    | 0.37533    |   0.0 |  0.25
Other   |            | 0.06034    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206442 ave      206442 max      206442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206442
Ave neighs/atom = 103.221
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.320564540299, Press = 2.4297415979018
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8025.1161     -8025.1161     -8110.5818     -8110.5818      330.76105      330.76105      24168.872      24168.872      2296.845       2296.845     
     25000  -8026.952      -8026.952      -8111.8692     -8111.8692      328.63835      328.63835      24192.9        24192.9        102.6034       102.6034     
Loop time of 149.693 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.581 hours/ns, 6.680 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.16     | 149.16     | 149.16     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097118   | 0.097118   | 0.097118   |   0.0 |  0.06
Output  | 0.00016541 | 0.00016541 | 0.00016541 |   0.0 |  0.00
Modify  | 0.37426    | 0.37426    | 0.37426    |   0.0 |  0.25
Other   |            | 0.06046    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206432 ave      206432 max      206432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206432
Ave neighs/atom = 103.216
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.281210381566, Press = 3.48049144561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8026.952      -8026.952      -8111.8692     -8111.8692      328.63835      328.63835      24192.9        24192.9        102.6034       102.6034     
     26000  -8019.9687     -8019.9687     -8109.0273     -8109.0273      344.66603      344.66603      24232.656      24232.656     -2362.8008     -2362.8008    
Loop time of 151.326 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.035 hours/ns, 6.608 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.79     | 150.79     | 150.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09835    | 0.09835    | 0.09835    |   0.0 |  0.06
Output  | 0.00016337 | 0.00016337 | 0.00016337 |   0.0 |  0.00
Modify  | 0.38073    | 0.38073    | 0.38073    |   0.0 |  0.25
Other   |            | 0.06104    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206104 ave      206104 max      206104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206104
Ave neighs/atom = 103.052
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.310323078904, Press = 2.41030432934109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8019.9687     -8019.9687     -8109.0273     -8109.0273      344.66603      344.66603      24232.656      24232.656     -2362.8008     -2362.8008    
     27000  -8026.7411     -8026.7411     -8110.5758     -8110.5758      324.44904      324.44904      24227.485      24227.485     -2686.2757     -2686.2757    
Loop time of 149.011 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.392 hours/ns, 6.711 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.48     | 148.48     | 148.48     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097457   | 0.097457   | 0.097457   |   0.0 |  0.07
Output  | 0.00016318 | 0.00016318 | 0.00016318 |   0.0 |  0.00
Modify  | 0.37693    | 0.37693    | 0.37693    |   0.0 |  0.25
Other   |            | 0.06041    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205134 ave      205134 max      205134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205134
Ave neighs/atom = 102.567
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.417837665349, Press = -0.0478421430829357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8026.7411     -8026.7411     -8110.5758     -8110.5758      324.44904      324.44904      24227.485      24227.485     -2686.2757     -2686.2757    
     28000  -8023.7551     -8023.7551     -8108.9093     -8108.9093      329.55573      329.55573      24212.408      24212.408     -1024.7539     -1024.7539    
Loop time of 148.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.287 hours/ns, 6.728 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.1      | 148.1      | 148.1      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096873   | 0.096873   | 0.096873   |   0.0 |  0.07
Output  | 0.00022013 | 0.00022013 | 0.00022013 |   0.0 |  0.00
Modify  | 0.37396    | 0.37396    | 0.37396    |   0.0 |  0.25
Other   |            | 0.06003    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205288 ave      205288 max      205288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205288
Ave neighs/atom = 102.644
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.437687770327, Press = -0.950938256991397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8023.7551     -8023.7551     -8108.9093     -8108.9093      329.55573      329.55573      24212.408      24212.408     -1024.7539     -1024.7539    
     29000  -8027.5602     -8027.5602     -8110.8899     -8110.8899      322.49457      322.49457      24198.907      24198.907     -299.31034     -299.31034    
Loop time of 148.544 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.262 hours/ns, 6.732 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.01     | 148.01     | 148.01     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09686    | 0.09686    | 0.09686    |   0.0 |  0.07
Output  | 0.00016359 | 0.00016359 | 0.00016359 |   0.0 |  0.00
Modify  | 0.3738     | 0.3738     | 0.3738     |   0.0 |  0.25
Other   |            | 0.06063    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205466 ave      205466 max      205466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205466
Ave neighs/atom = 102.733
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.432027919727, Press = -1.57163703992973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8027.5602     -8027.5602     -8110.8899     -8110.8899      322.49457      322.49457      24198.907      24198.907     -299.31034     -299.31034    
     30000  -8025.227      -8025.227      -8111.6622     -8111.6622      334.51324      334.51324      24192.146      24192.146      167.66096      167.66096    
Loop time of 149.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.475 hours/ns, 6.697 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.77     | 148.77     | 148.77     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097584   | 0.097584   | 0.097584   |   0.0 |  0.07
Output  | 0.00016618 | 0.00016618 | 0.00016618 |   0.0 |  0.00
Modify  | 0.37664    | 0.37664    | 0.37664    |   0.0 |  0.25
Other   |            | 0.06061    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205872 ave      205872 max      205872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205872
Ave neighs/atom = 102.936
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.498596596808, Press = -1.67327000781372
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8025.227      -8025.227      -8111.6622     -8111.6622      334.51324      334.51324      24192.146      24192.146      167.66096      167.66096    
     31000  -8020.6887     -8020.6887     -8108.5174     -8108.5174      339.90597      339.90597      24189.211      24189.211      1026.7808      1026.7808    
Loop time of 149.121 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.423 hours/ns, 6.706 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.59     | 148.59     | 148.59     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097008   | 0.097008   | 0.097008   |   0.0 |  0.07
Output  | 0.00024465 | 0.00024465 | 0.00024465 |   0.0 |  0.00
Modify  | 0.37411    | 0.37411    | 0.37411    |   0.0 |  0.25
Other   |            | 0.06074    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206010 ave      206010 max      206010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206010
Ave neighs/atom = 103.005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.551278289021, Press = -0.949949337661492
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8020.6887     -8020.6887     -8108.5174     -8108.5174      339.90597      339.90597      24189.211      24189.211      1026.7808      1026.7808    
     32000  -8025.9853     -8025.9853     -8111.5143     -8111.5143      331.00605      331.00605      24141.974      24141.974      4098.6054      4098.6054    
Loop time of 150.229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.730 hours/ns, 6.656 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.7      | 149.7      | 149.7      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097315   | 0.097315   | 0.097315   |   0.0 |  0.06
Output  | 0.00016696 | 0.00016696 | 0.00016696 |   0.0 |  0.00
Modify  | 0.37504    | 0.37504    | 0.37504    |   0.0 |  0.25
Other   |            | 0.06013    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205956 ave      205956 max      205956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205956
Ave neighs/atom = 102.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.618364202479, Press = -0.729287144027869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8025.9853     -8025.9853     -8111.5143     -8111.5143      331.00605      331.00605      24141.974      24141.974      4098.6054      4098.6054    
     33000  -8025          -8025          -8111.2206     -8111.2206      333.68252      333.68252      24148.057      24148.057      3493.8998      3493.8998    
Loop time of 150.183 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.717 hours/ns, 6.659 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.64     | 149.64     | 149.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097926   | 0.097926   | 0.097926   |   0.0 |  0.07
Output  | 0.00016441 | 0.00016441 | 0.00016441 |   0.0 |  0.00
Modify  | 0.37981    | 0.37981    | 0.37981    |   0.0 |  0.25
Other   |            | 0.0605     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206974 ave      206974 max      206974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206974
Ave neighs/atom = 103.487
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.636389087494, Press = 1.53957189284931
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8025          -8025          -8111.2206     -8111.2206      333.68252      333.68252      24148.057      24148.057      3493.8998      3493.8998    
     34000  -8023.3782     -8023.3782     -8107.2797     -8107.2797      324.7075       324.7075       24186.55       24186.55       1581.4324      1581.4324    
Loop time of 150.371 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.770 hours/ns, 6.650 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.84     | 149.84     | 149.84     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097018   | 0.097018   | 0.097018   |   0.0 |  0.06
Output  | 0.00016449 | 0.00016449 | 0.00016449 |   0.0 |  0.00
Modify  | 0.37677    | 0.37677    | 0.37677    |   0.0 |  0.25
Other   |            | 0.06066    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206806 ave      206806 max      206806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206806
Ave neighs/atom = 103.403
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.599119313855, Press = 2.36737616685007
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8023.3782     -8023.3782     -8107.2797     -8107.2797      324.7075       324.7075       24186.55       24186.55       1581.4324      1581.4324    
     35000  -8022.5456     -8022.5456     -8108.9575     -8108.9575      334.42292      334.42292      24218.172      24218.172     -1298.0647     -1298.0647    
Loop time of 149.647 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.569 hours/ns, 6.682 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.11     | 149.11     | 149.11     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097749   | 0.097749   | 0.097749   |   0.0 |  0.07
Output  | 0.00016466 | 0.00016466 | 0.00016466 |   0.0 |  0.00
Modify  | 0.37739    | 0.37739    | 0.37739    |   0.0 |  0.25
Other   |            | 0.0606     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205988 ave      205988 max      205988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205988
Ave neighs/atom = 102.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.602740439521, Press = 1.26155822954598
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8022.5456     -8022.5456     -8108.9575     -8108.9575      334.42292      334.42292      24218.172      24218.172     -1298.0647     -1298.0647    
     36000  -8024.2292     -8024.2292     -8110.0813     -8110.0813      332.25619      332.25619      24229.19       24229.19      -2390.0512     -2390.0512    
Loop time of 151.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.087 hours/ns, 6.600 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.97     | 150.97     | 150.97     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098292   | 0.098292   | 0.098292   |   0.0 |  0.06
Output  | 0.00016617 | 0.00016617 | 0.00016617 |   0.0 |  0.00
Modify  | 0.3818     | 0.3818     | 0.3818     |   0.0 |  0.25
Other   |            | 0.06066    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205568 ave      205568 max      205568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205568
Ave neighs/atom = 102.784
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.596064773351, Press = 0.501396695338876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8024.2292     -8024.2292     -8110.0813     -8110.0813      332.25619      332.25619      24229.19       24229.19      -2390.0512     -2390.0512    
     37000  -8025.956      -8025.956      -8112.5603     -8112.5603      335.16738      335.16738      24225.217      24225.217     -2448.8958     -2448.8958    
Loop time of 147.93 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.092 hours/ns, 6.760 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.4      | 147.4      | 147.4      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097706   | 0.097706   | 0.097706   |   0.0 |  0.07
Output  | 0.00016597 | 0.00016597 | 0.00016597 |   0.0 |  0.00
Modify  | 0.37428    | 0.37428    | 0.37428    |   0.0 |  0.25
Other   |            | 0.06075    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205164 ave      205164 max      205164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205164
Ave neighs/atom = 102.582
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.681383392149, Press = -1.39039981111066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8025.956      -8025.956      -8112.5603     -8112.5603      335.16738      335.16738      24225.217      24225.217     -2448.8958     -2448.8958    
     38000  -8023.1084     -8023.1084     -8110.3501     -8110.3501      337.63433      337.63433      24214.409      24214.409     -1199.8728     -1199.8728    
Loop time of 149.603 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.556 hours/ns, 6.684 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.07     | 149.07     | 149.07     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097315   | 0.097315   | 0.097315   |   0.0 |  0.07
Output  | 0.00016549 | 0.00016549 | 0.00016549 |   0.0 |  0.00
Modify  | 0.37694    | 0.37694    | 0.37694    |   0.0 |  0.25
Other   |            | 0.06166    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205486 ave      205486 max      205486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205486
Ave neighs/atom = 102.743
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.693530200398, Press = -2.15791300612953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8023.1084     -8023.1084     -8110.3501     -8110.3501      337.63433      337.63433      24214.409      24214.409     -1199.8728     -1199.8728    
     39000  -8022.4979     -8022.4979     -8110.141      -8110.141       339.1879       339.1879       24171.061      24171.061      2364.6081      2364.6081    
Loop time of 149.927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.646 hours/ns, 6.670 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.39     | 149.39     | 149.39     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097968   | 0.097968   | 0.097968   |   0.0 |  0.07
Output  | 0.00016365 | 0.00016365 | 0.00016365 |   0.0 |  0.00
Modify  | 0.37688    | 0.37688    | 0.37688    |   0.0 |  0.25
Other   |            | 0.06107    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205574 ave      205574 max      205574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205574
Ave neighs/atom = 102.787
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.712772568593, Press = -3.99774607604414
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8022.4979     -8022.4979     -8110.141      -8110.141       339.1879       339.1879       24171.061      24171.061      2364.6081      2364.6081    
     40000  -8026.2413     -8026.2413     -8111.6082     -8111.6082      330.37905      330.37905      24160.554      24160.554      2760.7061      2760.7061    
Loop time of 151.177 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.994 hours/ns, 6.615 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.64     | 150.64     | 150.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097752   | 0.097752   | 0.097752   |   0.0 |  0.06
Output  | 0.00016358 | 0.00016358 | 0.00016358 |   0.0 |  0.00
Modify  | 0.37874    | 0.37874    | 0.37874    |   0.0 |  0.25
Other   |            | 0.06063    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206344 ave      206344 max      206344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206344
Ave neighs/atom = 103.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.794238215117, Press = -0.417910387189651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8026.2413     -8026.2413     -8111.6082     -8111.6082      330.37905      330.37905      24160.554      24160.554      2760.7061      2760.7061    
     41000  -8024.0736     -8024.0736     -8111.1149     -8111.1149      336.85879      336.85879      24171.992      24171.992      2044.817       2044.817     
Loop time of 150.513 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.809 hours/ns, 6.644 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.98     | 149.98     | 149.98     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097495   | 0.097495   | 0.097495   |   0.0 |  0.06
Output  | 0.00016454 | 0.00016454 | 0.00016454 |   0.0 |  0.00
Modify  | 0.37847    | 0.37847    | 0.37847    |   0.0 |  0.25
Other   |            | 0.0605     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206722 ave      206722 max      206722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206722
Ave neighs/atom = 103.361
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.799335436948, Press = 0.466847493644955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8024.0736     -8024.0736     -8111.1149     -8111.1149      336.85879      336.85879      24171.992      24171.992      2044.817       2044.817     
     42000  -8024.7698     -8024.7698     -8112.3227     -8112.3227      338.83858      338.83858      24187.434      24187.434      586.04939      586.04939    
Loop time of 148.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.332 hours/ns, 6.721 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.27     | 148.27     | 148.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096878   | 0.096878   | 0.096878   |   0.0 |  0.07
Output  | 0.00020269 | 0.00020269 | 0.00020269 |   0.0 |  0.00
Modify  | 0.37088    | 0.37088    | 0.37088    |   0.0 |  0.25
Other   |            | 0.06039    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206620 ave      206620 max      206620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206620
Ave neighs/atom = 103.31
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.695146796818, Press = 1.13881000633709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8024.7698     -8024.7698     -8112.3227     -8112.3227      338.83858      338.83858      24187.434      24187.434      586.04939      586.04939    
     43000  -8027.8711     -8027.8711     -8113.1887     -8113.1887      330.1881       330.1881       24193.952      24193.952     -270.90324     -270.90324    
Loop time of 148.876 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.354 hours/ns, 6.717 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.35     | 148.35     | 148.35     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096732   | 0.096732   | 0.096732   |   0.0 |  0.06
Output  | 0.00016409 | 0.00016409 | 0.00016409 |   0.0 |  0.00
Modify  | 0.37273    | 0.37273    | 0.37273    |   0.0 |  0.25
Other   |            | 0.06039    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206406 ave      206406 max      206406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206406
Ave neighs/atom = 103.203
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.658232093763, Press = 1.5470198469782
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8027.8711     -8027.8711     -8113.1887     -8113.1887      330.1881       330.1881       24193.952      24193.952     -270.90324     -270.90324    
     44000  -8021.7273     -8021.7273     -8108.67       -8108.67        336.47746      336.47746      24239.718      24239.718     -2815.4336     -2815.4336    
Loop time of 150.117 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.699 hours/ns, 6.661 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.58     | 149.58     | 149.58     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098088   | 0.098088   | 0.098088   |   0.0 |  0.07
Output  | 0.00016521 | 0.00016521 | 0.00016521 |   0.0 |  0.00
Modify  | 0.3769     | 0.3769     | 0.3769     |   0.0 |  0.25
Other   |            | 0.061      |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206172 ave      206172 max      206172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206172
Ave neighs/atom = 103.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.62144856671, Press = 2.26635459597681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8021.7273     -8021.7273     -8108.67       -8108.67        336.47746      336.47746      24239.718      24239.718     -2815.4336     -2815.4336    
     45000  -8028.2471     -8028.2471     -8112.87       -8112.87        327.49917      327.49917      24239.657      24239.657     -3950.6454     -3950.6454    
Loop time of 148.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.367 hours/ns, 6.715 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.39     | 148.39     | 148.39     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097377   | 0.097377   | 0.097377   |   0.0 |  0.07
Output  | 0.00016609 | 0.00016609 | 0.00016609 |   0.0 |  0.00
Modify  | 0.37383    | 0.37383    | 0.37383    |   0.0 |  0.25
Other   |            | 0.05998    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205100 ave      205100 max      205100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205100
Ave neighs/atom = 102.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.593967751286, Press = 0.11047189416247
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8028.2471     -8028.2471     -8112.87       -8112.87        327.49917      327.49917      24239.657      24239.657     -3950.6454     -3950.6454    
     46000  -8023.2254     -8023.2254     -8108.6786     -8108.6786      330.71262      330.71262      24226.665      24226.665     -2037.3087     -2037.3087    
Loop time of 150.186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.718 hours/ns, 6.658 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.65     | 149.65     | 149.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097758   | 0.097758   | 0.097758   |   0.0 |  0.07
Output  | 0.00024959 | 0.00024959 | 0.00024959 |   0.0 |  0.00
Modify  | 0.37671    | 0.37671    | 0.37671    |   0.0 |  0.25
Other   |            | 0.06042    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205510 ave      205510 max      205510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205510
Ave neighs/atom = 102.755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.565367168916, Press = -1.01378715154667
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8023.2254     -8023.2254     -8108.6786     -8108.6786      330.71262      330.71262      24226.665      24226.665     -2037.3087     -2037.3087    
     47000  -8025.6241     -8025.6241     -8112.0945     -8112.0945      334.64947      334.64947      24201.647      24201.647     -454.59452     -454.59452    
Loop time of 149.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.596 hours/ns, 6.678 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.21     | 149.21     | 149.21     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097264   | 0.097264   | 0.097264   |   0.0 |  0.06
Output  | 0.00020162 | 0.00020162 | 0.00020162 |   0.0 |  0.00
Modify  | 0.37924    | 0.37924    | 0.37924    |   0.0 |  0.25
Other   |            | 0.06116    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205284 ave      205284 max      205284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205284
Ave neighs/atom = 102.642
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.579405296857, Press = -1.05742657634542
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8025.6241     -8025.6241     -8112.0945     -8112.0945      334.64947      334.64947      24201.647      24201.647     -454.59452     -454.59452    
     48000  -8020.229      -8020.229      -8108.0354     -8108.0354      339.81959      339.81959      24197.213      24197.213      801.59099      801.59099    
Loop time of 148.722 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.312 hours/ns, 6.724 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.19     | 148.19     | 148.19     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097183   | 0.097183   | 0.097183   |   0.0 |  0.07
Output  | 0.00016411 | 0.00016411 | 0.00016411 |   0.0 |  0.00
Modify  | 0.37447    | 0.37447    | 0.37447    |   0.0 |  0.25
Other   |            | 0.06082    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205876 ave      205876 max      205876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205876
Ave neighs/atom = 102.938
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.636463395505, Press = -1.54053931952995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8020.229      -8020.229      -8108.0354     -8108.0354      339.81959      339.81959      24197.213      24197.213      801.59099      801.59099    
     49000  -8025.6192     -8025.6192     -8111.4329     -8111.4329      332.10786      332.10786      24161.465      24161.465      2618.4695      2618.4695    
Loop time of 150.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.874 hours/ns, 6.634 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.21     | 150.21     | 150.21     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097914   | 0.097914   | 0.097914   |   0.0 |  0.06
Output  | 0.00017134 | 0.00017134 | 0.00017134 |   0.0 |  0.00
Modify  | 0.37985    | 0.37985    | 0.37985    |   0.0 |  0.25
Other   |            | 0.06078    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205788 ave      205788 max      205788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205788
Ave neighs/atom = 102.894
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.652477711552, Press = -0.00430129995871862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8025.6192     -8025.6192     -8111.4329     -8111.4329      332.10786      332.10786      24161.465      24161.465      2618.4695      2618.4695    
     50000  -8021.737      -8021.737      -8108.9065     -8108.9065      337.35492      337.35492      24168.496      24168.496      2842.6972      2842.6972    
Loop time of 150.541 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.817 hours/ns, 6.643 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150        | 150        | 150        |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098185   | 0.098185   | 0.098185   |   0.0 |  0.07
Output  | 0.00016413 | 0.00016413 | 0.00016413 |   0.0 |  0.00
Modify  | 0.38255    | 0.38255    | 0.38255    |   0.0 |  0.25
Other   |            | 0.06057    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206762 ave      206762 max      206762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206762
Ave neighs/atom = 103.381
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.658228520431, Press = 1.00526781303637
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8021.737      -8021.737      -8108.9065     -8108.9065      337.35492      337.35492      24168.496      24168.496      2842.6972      2842.6972    
     51000  -8027.5386     -8027.5386     -8110.8656     -8110.8656      322.48399      322.48399      24185.883      24185.883      771.74902      771.74902    
Loop time of 150.965 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.935 hours/ns, 6.624 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.43     | 150.43     | 150.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098478   | 0.098478   | 0.098478   |   0.0 |  0.07
Output  | 0.00016457 | 0.00016457 | 0.00016457 |   0.0 |  0.00
Modify  | 0.37932    | 0.37932    | 0.37932    |   0.0 |  0.25
Other   |            | 0.0608     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206546 ave      206546 max      206546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206546
Ave neighs/atom = 103.273
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.659807775933, Press = 1.31104104242833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8027.5386     -8027.5386     -8110.8656     -8110.8656      322.48399      322.48399      24185.883      24185.883      771.74902      771.74902    
     52000  -8024.8796     -8024.8796     -8109.9046     -8109.9046      329.05536      329.05536      24206.912      24206.912     -711.41659     -711.41659    
Loop time of 148.383 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.218 hours/ns, 6.739 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.86     | 147.86     | 147.86     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096611   | 0.096611   | 0.096611   |   0.0 |  0.07
Output  | 0.00016579 | 0.00016579 | 0.00016579 |   0.0 |  0.00
Modify  | 0.37125    | 0.37125    | 0.37125    |   0.0 |  0.25
Other   |            | 0.06009    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206252 ave      206252 max      206252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206252
Ave neighs/atom = 103.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.657511678266, Press = 0.756412136063923
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8024.8796     -8024.8796     -8109.9046     -8109.9046      329.05536      329.05536      24206.912      24206.912     -711.41659     -711.41659    
     53000  -8022.0804     -8022.0804     -8109.6244     -8109.6244      338.80439      338.80439      24225.084      24225.084     -1758.2761     -1758.2761    
Loop time of 149.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.592 hours/ns, 6.679 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.2      | 149.2      | 149.2      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097578   | 0.097578   | 0.097578   |   0.0 |  0.07
Output  | 0.000165   | 0.000165   | 0.000165   |   0.0 |  0.00
Modify  | 0.3762     | 0.3762     | 0.3762     |   0.0 |  0.25
Other   |            | 0.06011    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205734 ave      205734 max      205734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205734
Ave neighs/atom = 102.867
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.63500120465, Press = 0.2484228696934
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8022.0804     -8022.0804     -8109.6244     -8109.6244      338.80439      338.80439      24225.084      24225.084     -1758.2761     -1758.2761    
     54000  -8024.259      -8024.259      -8109.5781     -8109.5781      330.19364      330.19364      24235.548      24235.548     -2676.0784     -2676.0784    
Loop time of 150.66 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.850 hours/ns, 6.637 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.12     | 150.12     | 150.12     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097718   | 0.097718   | 0.097718   |   0.0 |  0.06
Output  | 0.00016623 | 0.00016623 | 0.00016623 |   0.0 |  0.00
Modify  | 0.37978    | 0.37978    | 0.37978    |   0.0 |  0.25
Other   |            | 0.06056    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205420 ave      205420 max      205420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205420
Ave neighs/atom = 102.71
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.638978075605, Press = -0.51718985718285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8024.259      -8024.259      -8109.5781     -8109.5781      330.19364      330.19364      24235.548      24235.548     -2676.0784     -2676.0784    
     55000  -8025.393      -8025.393      -8110.7059     -8110.7059      330.16982      330.16982      24228.917      24228.917     -2352.0604     -2352.0604    
Loop time of 148.333 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.204 hours/ns, 6.742 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.8      | 147.8      | 147.8      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096521   | 0.096521   | 0.096521   |   0.0 |  0.07
Output  | 0.00016686 | 0.00016686 | 0.00016686 |   0.0 |  0.00
Modify  | 0.37462    | 0.37462    | 0.37462    |   0.0 |  0.25
Other   |            | 0.06054    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205224 ave      205224 max      205224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205224
Ave neighs/atom = 102.612
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.691487938818, Press = -1.89480326553278
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8025.393      -8025.393      -8110.7059     -8110.7059      330.16982      330.16982      24228.917      24228.917     -2352.0604     -2352.0604    
     56000  -8022.2282     -8022.2282     -8110.4206     -8110.4206      341.3137       341.3137       24200.203      24200.203      81.180115      81.180115    
Loop time of 148.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.360 hours/ns, 6.716 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.36     | 148.36     | 148.36     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096859   | 0.096859   | 0.096859   |   0.0 |  0.07
Output  | 0.00016488 | 0.00016488 | 0.00016488 |   0.0 |  0.00
Modify  | 0.37637    | 0.37637    | 0.37637    |   0.0 |  0.25
Other   |            | 0.0604     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205264 ave      205264 max      205264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205264
Ave neighs/atom = 102.632
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.714962315959, Press = -1.29700201490168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8022.2282     -8022.2282     -8110.4206     -8110.4206      341.3137       341.3137       24200.203      24200.203      81.180115      81.180115    
     57000  -8024.8685     -8024.8685     -8112.6623     -8112.6623      339.77113      339.77113      24178.071      24178.071      1420.2054      1420.2054    
Loop time of 149.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.436 hours/ns, 6.704 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.64     | 148.64     | 148.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097173   | 0.097173   | 0.097173   |   0.0 |  0.07
Output  | 0.0001642  | 0.0001642  | 0.0001642  |   0.0 |  0.00
Modify  | 0.37335    | 0.37335    | 0.37335    |   0.0 |  0.25
Other   |            | 0.06017    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205798 ave      205798 max      205798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205798
Ave neighs/atom = 102.899
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.736452128761, Press = -0.653938693915061
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8024.8685     -8024.8685     -8112.6623     -8112.6623      339.77113      339.77113      24178.071      24178.071      1420.2054      1420.2054    
     58000  -8024.7028     -8024.7028     -8111.4424     -8111.4424      335.69104      335.69104      24170.703      24170.703      2316.0285      2316.0285    
Loop time of 149.642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.567 hours/ns, 6.683 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.11     | 149.11     | 149.11     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096649   | 0.096649   | 0.096649   |   0.0 |  0.06
Output  | 0.00020711 | 0.00020711 | 0.00020711 |   0.0 |  0.00
Modify  | 0.37065    | 0.37065    | 0.37065    |   0.0 |  0.25
Other   |            | 0.06048    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206688 ave      206688 max      206688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206688
Ave neighs/atom = 103.344
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.724710551444, Press = 0.00267741392954631
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8024.7028     -8024.7028     -8111.4424     -8111.4424      335.69104      335.69104      24170.703      24170.703      2316.0285      2316.0285    
     59000  -8026.693      -8026.693      -8111.6548     -8111.6548      328.81102      328.81102      24170.09       24170.09       1880.5757      1880.5757    
Loop time of 149.555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.543 hours/ns, 6.687 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.02     | 149.02     | 149.02     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098029   | 0.098029   | 0.098029   |   0.0 |  0.07
Output  | 0.00020219 | 0.00020219 | 0.00020219 |   0.0 |  0.00
Modify  | 0.37443    | 0.37443    | 0.37443    |   0.0 |  0.25
Other   |            | 0.06025    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206632 ave      206632 max      206632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206632
Ave neighs/atom = 103.316
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.706740488416, Press = 1.06799739766936
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8026.693      -8026.693      -8111.6548     -8111.6548      328.81102      328.81102      24170.09       24170.09       1880.5757      1880.5757    
     60000  -8025.1071     -8025.1071     -8112.2818     -8112.2818      337.37497      337.37497      24190.717      24190.717      415.1642       415.1642     
Loop time of 149.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.639 hours/ns, 6.671 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.36     | 149.36     | 149.36     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09751    | 0.09751    | 0.09751    |   0.0 |  0.07
Output  | 0.00020328 | 0.00020328 | 0.00020328 |   0.0 |  0.00
Modify  | 0.37943    | 0.37943    | 0.37943    |   0.0 |  0.25
Other   |            | 0.06082    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206492 ave      206492 max      206492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206492
Ave neighs/atom = 103.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.737080082477, Press = 1.57319932686282
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8025.1071     -8025.1071     -8112.2818     -8112.2818      337.37497      337.37497      24190.717      24190.717      415.1642       415.1642     
     61000  -8025.1472     -8025.1472     -8110.9144     -8110.9144      331.92817      331.92817      24222.022      24222.022     -1934.756      -1934.756     
Loop time of 151.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.121 hours/ns, 6.595 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.09     | 151.09     | 151.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098619   | 0.098619   | 0.098619   |   0.0 |  0.07
Output  | 0.00016324 | 0.00016324 | 0.00016324 |   0.0 |  0.00
Modify  | 0.38112    | 0.38112    | 0.38112    |   0.0 |  0.25
Other   |            | 0.06061    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206332 ave      206332 max      206332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206332
Ave neighs/atom = 103.166
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.760170426368, Press = 1.36734555301364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8025.1472     -8025.1472     -8110.9144     -8110.9144      331.92817      331.92817      24222.022      24222.022     -1934.756      -1934.756     
     62000  -8029.3554     -8029.3554     -8111.9246     -8111.9246      319.55157      319.55157      24221.249      24221.249     -2159.9185     -2159.9185    
Loop time of 150.324 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.757 hours/ns, 6.652 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.78     | 149.78     | 149.78     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098607   | 0.098607   | 0.098607   |   0.0 |  0.07
Output  | 0.00016557 | 0.00016557 | 0.00016557 |   0.0 |  0.00
Modify  | 0.38077    | 0.38077    | 0.38077    |   0.0 |  0.25
Other   |            | 0.06045    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205598 ave      205598 max      205598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205598
Ave neighs/atom = 102.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.749266041156, Press = 0.38592716815333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8029.3554     -8029.3554     -8111.9246     -8111.9246      319.55157      319.55157      24221.249      24221.249     -2159.9185     -2159.9185    
     63000  -8024.0875     -8024.0875     -8110.7097     -8110.7097      335.23676      335.23676      24216.721      24216.721     -1411.9208     -1411.9208    
Loop time of 149.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.456 hours/ns, 6.701 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.71     | 148.71     | 148.71     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097817   | 0.097817   | 0.097817   |   0.0 |  0.07
Output  | 0.00016452 | 0.00016452 | 0.00016452 |   0.0 |  0.00
Modify  | 0.37725    | 0.37725    | 0.37725    |   0.0 |  0.25
Other   |            | 0.06013    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205502 ave      205502 max      205502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205502
Ave neighs/atom = 102.751
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.710375494925, Press = -0.254695902226346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8024.0875     -8024.0875     -8110.7097     -8110.7097      335.23676      335.23676      24216.721      24216.721     -1411.9208     -1411.9208    
     64000  -8027.1113     -8027.1113     -8111.2869     -8111.2869      325.76841      325.76841      24195.325      24195.325      55.80825       55.80825     
Loop time of 148.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.169 hours/ns, 6.747 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.68     | 147.68     | 147.68     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096504   | 0.096504   | 0.096504   |   0.0 |  0.07
Output  | 0.0001657  | 0.0001657  | 0.0001657  |   0.0 |  0.00
Modify  | 0.37325    | 0.37325    | 0.37325    |   0.0 |  0.25
Other   |            | 0.06033    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205508 ave      205508 max      205508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205508
Ave neighs/atom = 102.754
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.6462914149, Press = -0.394364124668029
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8027.1113     -8027.1113     -8111.2869     -8111.2869      325.76841      325.76841      24195.325      24195.325      55.80825       55.80825     
     65000  -8025.092      -8025.092      -8112.7342     -8112.7342      339.18438      339.18438      24183          24183          795.14244      795.14244    
Loop time of 151.219 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.005 hours/ns, 6.613 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.68     | 150.68     | 150.68     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097885   | 0.097885   | 0.097885   |   0.0 |  0.06
Output  | 0.00016695 | 0.00016695 | 0.00016695 |   0.0 |  0.00
Modify  | 0.37909    | 0.37909    | 0.37909    |   0.0 |  0.25
Other   |            | 0.06097    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205996 ave      205996 max      205996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205996
Ave neighs/atom = 102.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.633723485825, Press = -0.346352345819932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8025.092      -8025.092      -8112.7342     -8112.7342      339.18438      339.18438      24183          24183          795.14244      795.14244    
     66000  -8024.2146     -8024.2146     -8112.2586     -8112.2586      340.73958      340.73958      24170.332      24170.332      1872.2249      1872.2249    
Loop time of 151.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.955 hours/ns, 6.621 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.5      | 150.5      | 150.5      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0974     | 0.0974     | 0.0974     |   0.0 |  0.06
Output  | 0.00016604 | 0.00016604 | 0.00016604 |   0.0 |  0.00
Modify  | 0.37908    | 0.37908    | 0.37908    |   0.0 |  0.25
Other   |            | 0.06054    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206482 ave      206482 max      206482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206482
Ave neighs/atom = 103.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.608937473094, Press = 0.179552464657746
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8024.2146     -8024.2146     -8112.2586     -8112.2586      340.73958      340.73958      24170.332      24170.332      1872.2249      1872.2249    
     67000  -8026.1894     -8026.1894     -8110.5786     -8110.5786      326.59486      326.59486      24152.686      24152.686      3310.0858      3310.0858    
Loop time of 152.495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.360 hours/ns, 6.558 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.95     | 151.95     | 151.95     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0994     | 0.0994     | 0.0994     |   0.0 |  0.07
Output  | 0.00016378 | 0.00016378 | 0.00016378 |   0.0 |  0.00
Modify  | 0.38433    | 0.38433    | 0.38433    |   0.0 |  0.25
Other   |            | 0.06078    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206630 ave      206630 max      206630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206630
Ave neighs/atom = 103.315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.625868855708, Press = 1.1163571172762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8026.1894     -8026.1894     -8110.5786     -8110.5786      326.59486      326.59486      24152.686      24152.686      3310.0858      3310.0858    
     68000  -8020.7282     -8020.7282     -8109.2079     -8109.2079      342.42551      342.42551      24188.671      24188.671      989.33324      989.33324    
Loop time of 151.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 41.998 hours/ns, 6.614 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.66     | 150.66     | 150.66     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09774    | 0.09774    | 0.09774    |   0.0 |  0.06
Output  | 0.0001993  | 0.0001993  | 0.0001993  |   0.0 |  0.00
Modify  | 0.37939    | 0.37939    | 0.37939    |   0.0 |  0.25
Other   |            | 0.06034    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206776 ave      206776 max      206776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206776
Ave neighs/atom = 103.388
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.66107313866, Press = 1.70327649255272
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8020.7282     -8020.7282     -8109.2079     -8109.2079      342.42551      342.42551      24188.671      24188.671      989.33324      989.33324    
     69000  -8025.0764     -8025.0764     -8112.3127     -8112.3127      337.6136       337.6136       24213.984      24213.984     -1511.5953     -1511.5953    
Loop time of 150.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.931 hours/ns, 6.625 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.41     | 150.41     | 150.41     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098279   | 0.098279   | 0.098279   |   0.0 |  0.07
Output  | 0.00016385 | 0.00016385 | 0.00016385 |   0.0 |  0.00
Modify  | 0.38278    | 0.38278    | 0.38278    |   0.0 |  0.25
Other   |            | 0.06117    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205896 ave      205896 max      205896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205896
Ave neighs/atom = 102.948
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.703929479994, Press = 0.857401194215617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8025.0764     -8025.0764     -8112.3127     -8112.3127      337.6136       337.6136       24213.984      24213.984     -1511.5953     -1511.5953    
     70000  -8021.7565     -8021.7565     -8106.6543     -8106.6543      328.56355      328.56355      24221.91       24221.91      -1111.8133     -1111.8133    
Loop time of 151.303 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.029 hours/ns, 6.609 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.76     | 150.76     | 150.76     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098181   | 0.098181   | 0.098181   |   0.0 |  0.06
Output  | 0.00016458 | 0.00016458 | 0.00016458 |   0.0 |  0.00
Modify  | 0.38104    | 0.38104    | 0.38104    |   0.0 |  0.25
Other   |            | 0.06054    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205728 ave      205728 max      205728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205728
Ave neighs/atom = 102.864
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.702464785677, Press = 0.620257946118021
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8021.7565     -8021.7565     -8106.6543     -8106.6543      328.56355      328.56355      24221.91       24221.91      -1111.8133     -1111.8133    
     71000  -8024.8287     -8024.8287     -8111.7231     -8111.7231      336.29062      336.29062      24221.695      24221.695     -2222.3844     -2222.3844    
Loop time of 149.787 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.608 hours/ns, 6.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.25     | 149.25     | 149.25     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097479   | 0.097479   | 0.097479   |   0.0 |  0.07
Output  | 0.00020027 | 0.00020027 | 0.00020027 |   0.0 |  0.00
Modify  | 0.37945    | 0.37945    | 0.37945    |   0.0 |  0.25
Other   |            | 0.06097    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205228 ave      205228 max      205228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205228
Ave neighs/atom = 102.614
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.739918393933, Press = -0.25031062565104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -8024.8287     -8024.8287     -8111.7231     -8111.7231      336.29062      336.29062      24221.695      24221.695     -2222.3844     -2222.3844    
     72000  -8021.7093     -8021.7093     -8108.0362     -8108.0362      334.09415      334.09415      24218.654      24218.654     -1214.0387     -1214.0387    
Loop time of 150.235 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.732 hours/ns, 6.656 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.7      | 149.7      | 149.7      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096954   | 0.096954   | 0.096954   |   0.0 |  0.06
Output  | 0.00020181 | 0.00020181 | 0.00020181 |   0.0 |  0.00
Modify  | 0.37859    | 0.37859    | 0.37859    |   0.0 |  0.25
Other   |            | 0.06155    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205418 ave      205418 max      205418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205418
Ave neighs/atom = 102.709
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.740136835989, Press = -0.571043102578948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -8021.7093     -8021.7093     -8108.0362     -8108.0362      334.09415      334.09415      24218.654      24218.654     -1214.0387     -1214.0387    
     73000  -8025.5935     -8025.5935     -8113.7504     -8113.7504      341.17631      341.17631      24187.093      24187.093      191.89111      191.89111    
Loop time of 149.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.547 hours/ns, 6.686 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.03     | 149.03     | 149.03     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097309   | 0.097309   | 0.097309   |   0.0 |  0.07
Output  | 0.00020798 | 0.00020798 | 0.00020798 |   0.0 |  0.00
Modify  | 0.3779     | 0.3779     | 0.3779     |   0.0 |  0.25
Other   |            | 0.06116    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205314 ave      205314 max      205314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205314
Ave neighs/atom = 102.657
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.710728031607, Press = -1.03066306046899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -8025.5935     -8025.5935     -8113.7504     -8113.7504      341.17631      341.17631      24187.093      24187.093      191.89111      191.89111    
     74000  -8020.0488     -8020.0488     -8106.6275     -8106.6275      335.06866      335.06866      24159.629      24159.629      3654.4952      3654.4952    
Loop time of 149.773 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.603 hours/ns, 6.677 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.24     | 149.24     | 149.24     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097136   | 0.097136   | 0.097136   |   0.0 |  0.06
Output  | 0.0002014  | 0.0002014  | 0.0002014  |   0.0 |  0.00
Modify  | 0.37474    | 0.37474    | 0.37474    |   0.0 |  0.25
Other   |            | 0.06066    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206348 ave      206348 max      206348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206348
Ave neighs/atom = 103.174
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.724948033842, Press = -0.212221358257693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -8020.0488     -8020.0488     -8106.6275     -8106.6275      335.06866      335.06866      24159.629      24159.629      3654.4952      3654.4952    
     75000  -8025.3393     -8025.3393     -8110.2953     -8110.2953      328.78849      328.78849      24152.59       24152.59       3429.7231      3429.7231    
Loop time of 149.783 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.606 hours/ns, 6.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.25     | 149.25     | 149.25     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097245   | 0.097245   | 0.097245   |   0.0 |  0.06
Output  | 0.00019946 | 0.00019946 | 0.00019946 |   0.0 |  0.00
Modify  | 0.37778    | 0.37778    | 0.37778    |   0.0 |  0.25
Other   |            | 0.06029    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206228 ave      206228 max      206228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206228
Ave neighs/atom = 103.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.749768214563, Press = 0.750999298107526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -8025.3393     -8025.3393     -8110.2953     -8110.2953      328.78849      328.78849      24152.59       24152.59       3429.7231      3429.7231    
     76000  -8020.8326     -8020.8326     -8108.8111     -8108.8111      340.48587      340.48587      24193.323      24193.323      688.27805      688.27805    
Loop time of 151.027 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.952 hours/ns, 6.621 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.49     | 150.49     | 150.49     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097455   | 0.097455   | 0.097455   |   0.0 |  0.06
Output  | 0.00050929 | 0.00050929 | 0.00050929 |   0.0 |  0.00
Modify  | 0.38025    | 0.38025    | 0.38025    |   0.0 |  0.25
Other   |            | 0.06082    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206934 ave      206934 max      206934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206934
Ave neighs/atom = 103.467
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.779294252697, Press = 1.16716958785195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -8020.8326     -8020.8326     -8108.8111     -8108.8111      340.48587      340.48587      24193.323      24193.323      688.27805      688.27805    
     77000  -8026.2578     -8026.2578     -8110.8169     -8110.8169      327.25221      327.25221      24205.532      24205.532     -601.101       -601.101      
Loop time of 148.004 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.112 hours/ns, 6.757 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.48     | 147.48     | 147.48     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095643   | 0.095643   | 0.095643   |   0.0 |  0.06
Output  | 0.00016329 | 0.00016329 | 0.00016329 |   0.0 |  0.00
Modify  | 0.36841    | 0.36841    | 0.36841    |   0.0 |  0.25
Other   |            | 0.06026    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205806 ave      205806 max      205806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205806
Ave neighs/atom = 102.903
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.777211583065, Press = 0.638036782034471
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -8026.2578     -8026.2578     -8110.8169     -8110.8169      327.25221      327.25221      24205.532      24205.532     -601.101       -601.101      
     78000  -8026.749      -8026.749      -8112.0589     -8112.0589      330.15802      330.15802      24204.498      24204.498     -904.02488     -904.02488    
Loop time of 151.672 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.131 hours/ns, 6.593 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.13     | 151.13     | 151.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098284   | 0.098284   | 0.098284   |   0.0 |  0.06
Output  | 0.00016434 | 0.00016434 | 0.00016434 |   0.0 |  0.00
Modify  | 0.38358    | 0.38358    | 0.38358    |   0.0 |  0.25
Other   |            | 0.06157    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205818 ave      205818 max      205818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205818
Ave neighs/atom = 102.909
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.785704874659, Press = 0.0211472538612556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -8026.749      -8026.749      -8112.0589     -8112.0589      330.15802      330.15802      24204.498      24204.498     -904.02488     -904.02488    
     79000  -8024.2534     -8024.2534     -8110.8502     -8110.8502      335.13829      335.13829      24204.145      24204.145     -632.539       -632.539      
Loop time of 151.704 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.140 hours/ns, 6.592 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.16     | 151.16     | 151.16     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098462   | 0.098462   | 0.098462   |   0.0 |  0.06
Output  | 0.00022125 | 0.00022125 | 0.00022125 |   0.0 |  0.00
Modify  | 0.38295    | 0.38295    | 0.38295    |   0.0 |  0.25
Other   |            | 0.06137    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205914 ave      205914 max      205914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205914
Ave neighs/atom = 102.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.769710052378, Press = -0.247799913701342
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -8024.2534     -8024.2534     -8110.8502     -8110.8502      335.13829      335.13829      24204.145      24204.145     -632.539       -632.539      
     80000  -8024.0842     -8024.0842     -8111.0239     -8111.0239      336.46547      336.46547      24195.373      24195.373      102.88934      102.88934    
Loop time of 150.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.828 hours/ns, 6.641 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.04     | 150.04     | 150.04     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097722   | 0.097722   | 0.097722   |   0.0 |  0.06
Output  | 0.00016392 | 0.00016392 | 0.00016392 |   0.0 |  0.00
Modify  | 0.38026    | 0.38026    | 0.38026    |   0.0 |  0.25
Other   |            | 0.0611     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205728 ave      205728 max      205728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205728
Ave neighs/atom = 102.864
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.805924455115, Press = -0.717303253872918
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -8024.0842     -8024.0842     -8111.0239     -8111.0239      336.46547      336.46547      24195.373      24195.373      102.88934      102.88934    
     81000  -8024.7075     -8024.7075     -8112.3296     -8112.3296      339.10658      339.10658      24166.781      24166.781      2237.8825      2237.8825    
Loop time of 149.266 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.463 hours/ns, 6.699 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.73     | 148.73     | 148.73     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09667    | 0.09667    | 0.09667    |   0.0 |  0.06
Output  | 0.00020491 | 0.00020491 | 0.00020491 |   0.0 |  0.00
Modify  | 0.37507    | 0.37507    | 0.37507    |   0.0 |  0.25
Other   |            | 0.06087    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206044 ave      206044 max      206044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206044
Ave neighs/atom = 103.022
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.795246547222, Press = -0.834667488667244
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -8024.7075     -8024.7075     -8112.3296     -8112.3296      339.10658      339.10658      24166.781      24166.781      2237.8825      2237.8825    
     82000  -8022.831      -8022.831      -8111.6687     -8111.6687      343.8114       343.8114       24155.007      24155.007      2948.6335      2948.6335    
Loop time of 150.018 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.672 hours/ns, 6.666 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.48     | 149.48     | 149.48     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097441   | 0.097441   | 0.097441   |   0.0 |  0.06
Output  | 0.00016431 | 0.00016431 | 0.00016431 |   0.0 |  0.00
Modify  | 0.37676    | 0.37676    | 0.37676    |   0.0 |  0.25
Other   |            | 0.06076    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206754 ave      206754 max      206754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206754
Ave neighs/atom = 103.377
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.774075492095, Press = -0.0195341010912979
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -8022.831      -8022.831      -8111.6687     -8111.6687      343.8114       343.8114       24155.007      24155.007      2948.6335      2948.6335    
     83000  -8023.8454     -8023.8454     -8111.0984     -8111.0984      337.67829      337.67829      24167.171      24167.171      2368.9846      2368.9846    
Loop time of 150.704 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.862 hours/ns, 6.636 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.17     | 150.17     | 150.17     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097366   | 0.097366   | 0.097366   |   0.0 |  0.06
Output  | 0.00027479 | 0.00027479 | 0.00027479 |   0.0 |  0.00
Modify  | 0.37958    | 0.37958    | 0.37958    |   0.0 |  0.25
Other   |            | 0.06119    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206790 ave      206790 max      206790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206790
Ave neighs/atom = 103.395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.742230092073, Press = 0.532981775825797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -8023.8454     -8023.8454     -8111.0984     -8111.0984      337.67829      337.67829      24167.171      24167.171      2368.9846      2368.9846    
     84000  -8021.1812     -8021.1812     -8109.0223     -8109.0223      339.95384      339.95384      24188.813      24188.813      949.0274       949.0274     
Loop time of 149.694 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.582 hours/ns, 6.680 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.16     | 149.16     | 149.16     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097106   | 0.097106   | 0.097106   |   0.0 |  0.06
Output  | 0.00016604 | 0.00016604 | 0.00016604 |   0.0 |  0.00
Modify  | 0.37621    | 0.37621    | 0.37621    |   0.0 |  0.25
Other   |            | 0.06003    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206588 ave      206588 max      206588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206588
Ave neighs/atom = 103.294
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.770293687652, Press = 0.527851710282687
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -8021.1812     -8021.1812     -8109.0223     -8109.0223      339.95384      339.95384      24188.813      24188.813      949.0274       949.0274     
     85000  -8024.1167     -8024.1167     -8109.2171     -8109.2171      329.34745      329.34745      24205.575      24205.575     -318.24969     -318.24969    
Loop time of 149.643 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.567 hours/ns, 6.683 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.11     | 149.11     | 149.11     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096855   | 0.096855   | 0.096855   |   0.0 |  0.06
Output  | 0.00020618 | 0.00020618 | 0.00020618 |   0.0 |  0.00
Modify  | 0.37599    | 0.37599    | 0.37599    |   0.0 |  0.25
Other   |            | 0.06089    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205804 ave      205804 max      205804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205804
Ave neighs/atom = 102.902
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.770755249002, Press = 0.547346617476199
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -8024.1167     -8024.1167     -8109.2171     -8109.2171      329.34745      329.34745      24205.575      24205.575     -318.24969     -318.24969    
     86000  -8024.4905     -8024.4905     -8110.8135     -8110.8135      334.07908      334.07908      24219.771      24219.771     -1994.3836     -1994.3836    
Loop time of 149.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.521 hours/ns, 6.690 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.94     | 148.94     | 148.94     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097078   | 0.097078   | 0.097078   |   0.0 |  0.06
Output  | 0.00024843 | 0.00024843 | 0.00024843 |   0.0 |  0.00
Modify  | 0.37513    | 0.37513    | 0.37513    |   0.0 |  0.25
Other   |            | 0.06084    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205600 ave      205600 max      205600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205600
Ave neighs/atom = 102.8
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.786394619041, Press = 0.0705938729101262
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -8024.4905     -8024.4905     -8110.8135     -8110.8135      334.07908      334.07908      24219.771      24219.771     -1994.3836     -1994.3836    
     87000  -8027.8291     -8027.8291     -8113.6676     -8113.6676      332.20413      332.20413      24222.816      24222.816     -2688.3388     -2688.3388    
Loop time of 148.993 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.387 hours/ns, 6.712 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.46     | 148.46     | 148.46     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097064   | 0.097064   | 0.097064   |   0.0 |  0.07
Output  | 0.00016573 | 0.00016573 | 0.00016573 |   0.0 |  0.00
Modify  | 0.37612    | 0.37612    | 0.37612    |   0.0 |  0.25
Other   |            | 0.06052    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205524 ave      205524 max      205524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205524
Ave neighs/atom = 102.762
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.748401379055, Press = -0.570557503617865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -8027.8291     -8027.8291     -8113.6676     -8113.6676      332.20413      332.20413      24222.816      24222.816     -2688.3388     -2688.3388    
     88000  -8021.9293     -8021.9293     -8110.9699     -8110.9699      344.5966       344.5966       24207.854      24207.854     -912.68655     -912.68655    
Loop time of 152.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.336 hours/ns, 6.561 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.86     | 151.86     | 151.86     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098212   | 0.098212   | 0.098212   |   0.0 |  0.06
Output  | 0.00016566 | 0.00016566 | 0.00016566 |   0.0 |  0.00
Modify  | 0.38815    | 0.38815    | 0.38815    |   0.0 |  0.25
Other   |            | 0.0611     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205558 ave      205558 max      205558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205558
Ave neighs/atom = 102.779
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.755486212153, Press = -1.02179407657836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -8021.9293     -8021.9293     -8110.9699     -8110.9699      344.5966       344.5966       24207.854      24207.854     -912.68655     -912.68655    
     89000  -8021.8032     -8021.8032     -8111.2339     -8111.2339      346.10573      346.10573      24163.445      24163.445      2853.4889      2853.4889    
Loop time of 148.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.203 hours/ns, 6.742 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.8      | 147.8      | 147.8      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097492   | 0.097492   | 0.097492   |   0.0 |  0.07
Output  | 0.00016276 | 0.00016276 | 0.00016276 |   0.0 |  0.00
Modify  | 0.37411    | 0.37411    | 0.37411    |   0.0 |  0.25
Other   |            | 0.06157    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205602 ave      205602 max      205602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205602
Ave neighs/atom = 102.801
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.768601256683, Press = -0.881401107018896
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -8021.8032     -8021.8032     -8111.2339     -8111.2339      346.10573      346.10573      24163.445      24163.445      2853.4889      2853.4889    
     90000  -8028.3514     -8028.3514     -8113.2171     -8113.2171      328.43908      328.43908      24142.245      24142.245      3641.7633      3641.7633    
Loop time of 147.893 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.081 hours/ns, 6.762 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.36     | 147.36     | 147.36     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096294   | 0.096294   | 0.096294   |   0.0 |  0.07
Output  | 0.00016397 | 0.00016397 | 0.00016397 |   0.0 |  0.00
Modify  | 0.3728     | 0.3728     | 0.3728     |   0.0 |  0.25
Other   |            | 0.06055    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206668 ave      206668 max      206668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206668
Ave neighs/atom = 103.334
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.750870586898, Press = 0.151325804895864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -8028.3514     -8028.3514     -8113.2171     -8113.2171      328.43908      328.43908      24142.245      24142.245      3641.7633      3641.7633    
     91000  -8024.1301     -8024.1301     -8111.6534     -8111.6534      338.72411      338.72411      24183.167      24183.167      865.14509      865.14509    
Loop time of 150.753 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.876 hours/ns, 6.633 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.21     | 150.21     | 150.21     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097993   | 0.097993   | 0.097993   |   0.0 |  0.07
Output  | 0.00022501 | 0.00022501 | 0.00022501 |   0.0 |  0.00
Modify  | 0.38211    | 0.38211    | 0.38211    |   0.0 |  0.25
Other   |            | 0.06098    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207132 ave      207132 max      207132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207132
Ave neighs/atom = 103.566
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.717725989171, Press = 0.33459110238173
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -8024.1301     -8024.1301     -8111.6534     -8111.6534      338.72411      338.72411      24183.167      24183.167      865.14509      865.14509    
     92000  -8030.4612     -8030.4612     -8114.0181     -8114.0181      323.37392      323.37392      24180.645      24180.645      422.90059      422.90059    
Loop time of 151.458 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.072 hours/ns, 6.603 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.92     | 150.92     | 150.92     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097693   | 0.097693   | 0.097693   |   0.0 |  0.06
Output  | 0.00016367 | 0.00016367 | 0.00016367 |   0.0 |  0.00
Modify  | 0.37885    | 0.37885    | 0.37885    |   0.0 |  0.25
Other   |            | 0.06052    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206382 ave      206382 max      206382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206382
Ave neighs/atom = 103.191
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.685218763869, Press = 0.44384598023668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -8030.4612     -8030.4612     -8114.0181     -8114.0181      323.37392      323.37392      24180.645      24180.645      422.90059      422.90059    
     93000  -8023.1804     -8023.1804     -8111.6722     -8111.6722      342.47241      342.47241      24207.046      24207.046     -901.98573     -901.98573    
Loop time of 151.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.039 hours/ns, 6.608 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.8      | 150.8      | 150.8      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098962   | 0.098962   | 0.098962   |   0.0 |  0.07
Output  | 0.00020049 | 0.00020049 | 0.00020049 |   0.0 |  0.00
Modify  | 0.3802     | 0.3802     | 0.3802     |   0.0 |  0.25
Other   |            | 0.06096    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206546 ave      206546 max      206546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206546
Ave neighs/atom = 103.273
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.658623240758, Press = 0.559572943139543
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -8023.1804     -8023.1804     -8111.6722     -8111.6722      342.47241      342.47241      24207.046      24207.046     -901.98573     -901.98573    
     94000  -8024.7367     -8024.7367     -8110.2011     -8110.2011      330.75612      330.75612      24248.763      24248.763     -4129.3499     -4129.3499    
Loop time of 151.995 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.221 hours/ns, 6.579 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.45     | 151.45     | 151.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097755   | 0.097755   | 0.097755   |   0.0 |  0.06
Output  | 0.00016287 | 0.00016287 | 0.00016287 |   0.0 |  0.00
Modify  | 0.38178    | 0.38178    | 0.38178    |   0.0 |  0.25
Other   |            | 0.06174    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205738 ave      205738 max      205738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205738
Ave neighs/atom = 102.869
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.644875045245, Press = 0.520052509202997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -8024.7367     -8024.7367     -8110.2011     -8110.2011      330.75612      330.75612      24248.763      24248.763     -4129.3499     -4129.3499    
     95000  -8021.6683     -8021.6683     -8110.0545     -8110.0545      342.06364      342.06364      24256.093      24256.093     -4398.4884     -4398.4884    
Loop time of 150.947 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.930 hours/ns, 6.625 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.41     | 150.41     | 150.41     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098329   | 0.098329   | 0.098329   |   0.0 |  0.07
Output  | 0.00016292 | 0.00016292 | 0.00016292 |   0.0 |  0.00
Modify  | 0.38251    | 0.38251    | 0.38251    |   0.0 |  0.25
Other   |            | 0.06084    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204980 ave      204980 max      204980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204980
Ave neighs/atom = 102.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.639652824509, Press = -0.384874886261976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -8021.6683     -8021.6683     -8110.0545     -8110.0545      342.06364      342.06364      24256.093      24256.093     -4398.4884     -4398.4884    
     96000  -8026.6365     -8026.6365     -8111.1812     -8111.1812      327.1969       327.1969       24206.677      24206.677     -1230.429      -1230.429     
Loop time of 151.188 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 41.997 hours/ns, 6.614 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.65     | 150.65     | 150.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097503   | 0.097503   | 0.097503   |   0.0 |  0.06
Output  | 0.00019896 | 0.00019896 | 0.00019896 |   0.0 |  0.00
Modify  | 0.38156    | 0.38156    | 0.38156    |   0.0 |  0.25
Other   |            | 0.06112    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204682 ave      204682 max      204682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204682
Ave neighs/atom = 102.341
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.63417373841, Press = -0.43339571604012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -8026.6365     -8026.6365     -8111.1812     -8111.1812      327.1969       327.1969       24206.677      24206.677     -1230.429      -1230.429     
     97000  -8020.9885     -8020.9885     -8110.1912     -8110.1912      345.22364      345.22364      24192.243      24192.243      788.00057      788.00057    
Loop time of 153.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.729 hours/ns, 6.501 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.27     | 153.27     | 153.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099323   | 0.099323   | 0.099323   |   0.0 |  0.06
Output  | 0.00016427 | 0.00016427 | 0.00016427 |   0.0 |  0.00
Modify  | 0.3902     | 0.3902     | 0.3902     |   0.0 |  0.25
Other   |            | 0.06135    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205708 ave      205708 max      205708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205708
Ave neighs/atom = 102.854
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.636227515103, Press = -0.335172481914174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -8020.9885     -8020.9885     -8110.1912     -8110.1912      345.22364      345.22364      24192.243      24192.243      788.00057      788.00057    
     98000  -8025.7372     -8025.7372     -8113.6487     -8113.6487      340.22641      340.22641      24164.36       24164.36       1905.0851      1905.0851    
Loop time of 154.12 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.561 ns/day, 42.811 hours/ns, 6.488 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.57     | 153.57     | 153.57     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10047    | 0.10047    | 0.10047    |   0.0 |  0.07
Output  | 0.00016198 | 0.00016198 | 0.00016198 |   0.0 |  0.00
Modify  | 0.39309    | 0.39309    | 0.39309    |   0.0 |  0.26
Other   |            | 0.06143    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206182 ave      206182 max      206182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206182
Ave neighs/atom = 103.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.662713339955, Press = 0.0644434680935271
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -8025.7372     -8025.7372     -8113.6487     -8113.6487      340.22641      340.22641      24164.36       24164.36       1905.0851      1905.0851    
     99000  -8019.4333     -8019.4333     -8109.5794     -8109.5794      348.87473      348.87473      24155.92       24155.92       3589.187       3589.187     
Loop time of 151.993 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.220 hours/ns, 6.579 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.45     | 151.45     | 151.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098482   | 0.098482   | 0.098482   |   0.0 |  0.06
Output  | 0.00016487 | 0.00016487 | 0.00016487 |   0.0 |  0.00
Modify  | 0.38254    | 0.38254    | 0.38254    |   0.0 |  0.25
Other   |            | 0.06075    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206832 ave      206832 max      206832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206832
Ave neighs/atom = 103.416
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.670951494349, Press = 0.770164788147171
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -8019.4333     -8019.4333     -8109.5794     -8109.5794      348.87473      348.87473      24155.92       24155.92       3589.187       3589.187     
    100000  -8026.2539     -8026.2539     -8112.589      -8112.589       334.1255       334.1255       24171.753      24171.753      1674.0295      1674.0295    
Loop time of 150.624 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.840 hours/ns, 6.639 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.09     | 150.09     | 150.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097527   | 0.097527   | 0.097527   |   0.0 |  0.06
Output  | 0.00016543 | 0.00016543 | 0.00016543 |   0.0 |  0.00
Modify  | 0.37742    | 0.37742    | 0.37742    |   0.0 |  0.25
Other   |            | 0.06133    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206666 ave      206666 max      206666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206666
Ave neighs/atom = 103.333
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.692600179963, Press = 1.35060196851468
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -8026.2539     -8026.2539     -8112.589      -8112.589       334.1255       334.1255       24171.753      24171.753      1674.0295      1674.0295    
    101000  -8023.1673     -8023.1673     -8110.1619     -8110.1619      336.67815      336.67815      24205.535      24205.535     -628.87398     -628.87398    
Loop time of 152.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.295 hours/ns, 6.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    | 151.72     | 151.72     | 151.72     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098318   | 0.098318   | 0.098318   |   0.0 |  0.06
Output  | 0.00020426 | 0.00020426 | 0.00020426 |   0.0 |  0.00
Modify  | 0.38296    | 0.38296    | 0.38296    |   0.0 |  0.25
Other   |            | 0.06097    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206452 ave      206452 max      206452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206452
Ave neighs/atom = 103.226
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.707953601334, Press = 0.725605559138673
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -8023.1673     -8023.1673     -8110.1619     -8110.1619      336.67815      336.67815      24205.535      24205.535     -628.87398     -628.87398    
    102000  -8023.2506     -8023.2506     -8109.3873     -8109.3873      333.35775      333.35775      24208.161      24208.161     -604.30105     -604.30105    
Loop time of 151.22 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.006 hours/ns, 6.613 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.68     | 150.68     | 150.68     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097666   | 0.097666   | 0.097666   |   0.0 |  0.06
Output  | 0.00016576 | 0.00016576 | 0.00016576 |   0.0 |  0.00
Modify  | 0.37919    | 0.37919    | 0.37919    |   0.0 |  0.25
Other   |            | 0.06081    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205764 ave      205764 max      205764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205764
Ave neighs/atom = 102.882
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.683768666437, Press = 0.291996255109418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -8023.2506     -8023.2506     -8109.3873     -8109.3873      333.35775      333.35775      24208.161      24208.161     -604.30105     -604.30105    
    103000  -8028.1271     -8028.1271     -8110.9959     -8110.9959      320.71052      320.71052      24202.933      24202.933     -636.41908     -636.41908    
Loop time of 149.339 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.483 hours/ns, 6.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    | 148.81     | 148.81     | 148.81     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097201   | 0.097201   | 0.097201   |   0.0 |  0.07
Output  | 0.00016483 | 0.00016483 | 0.00016483 |   0.0 |  0.00
Modify  | 0.37583    | 0.37583    | 0.37583    |   0.0 |  0.25
Other   |            | 0.06069    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205570 ave      205570 max      205570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205570
Ave neighs/atom = 102.785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.665110886171, Press = 0.15688678461879
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -8028.1271     -8028.1271     -8110.9959     -8110.9959      320.71052      320.71052      24202.933      24202.933     -636.41908     -636.41908    
    104000  -8024.6079     -8024.6079     -8109.6361     -8109.6361      329.06809      329.06809      24214.301      24214.301     -1196.3598     -1196.3598    
Loop time of 151.616 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.116 hours/ns, 6.596 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.07     | 151.07     | 151.07     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098136   | 0.098136   | 0.098136   |   0.0 |  0.06
Output  | 0.00022184 | 0.00022184 | 0.00022184 |   0.0 |  0.00
Modify  | 0.3825     | 0.3825     | 0.3825     |   0.0 |  0.25
Other   |            | 0.0615     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205800 ave      205800 max      205800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205800
Ave neighs/atom = 102.9
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.618891821839, Press = -0.0911766223202614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -8024.6079     -8024.6079     -8109.6361     -8109.6361      329.06809      329.06809      24214.301      24214.301     -1196.3598     -1196.3598    
    105000  -8027.3137     -8027.3137     -8113.3872     -8113.3872      333.11338      333.11338      24208.152      24208.152     -1463.3331     -1463.3331    
Loop time of 150.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.853 hours/ns, 6.637 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.13     | 150.13     | 150.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099123   | 0.099123   | 0.099123   |   0.0 |  0.07
Output  | 0.00016346 | 0.00016346 | 0.00016346 |   0.0 |  0.00
Modify  | 0.38263    | 0.38263    | 0.38263    |   0.0 |  0.25
Other   |            | 0.06128    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205386 ave      205386 max      205386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205386
Ave neighs/atom = 102.693
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.61156192319, Press = -0.625899920683232
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -8027.3137     -8027.3137     -8113.3872     -8113.3872      333.11338      333.11338      24208.152      24208.152     -1463.3331     -1463.3331    
    106000  -8023.3661     -8023.3661     -8110.8536     -8110.8536      338.5857       338.5857       24191.378      24191.378      564.09876      564.09876    
Loop time of 150.228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.730 hours/ns, 6.657 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.69     | 149.69     | 149.69     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0976     | 0.0976     | 0.0976     |   0.0 |  0.06
Output  | 0.00016252 | 0.00016252 | 0.00016252 |   0.0 |  0.00
Modify  | 0.37839    | 0.37839    | 0.37839    |   0.0 |  0.25
Other   |            | 0.06042    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205812 ave      205812 max      205812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205812
Ave neighs/atom = 102.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.597059231783, Press = -0.837986061301213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -8023.3661     -8023.3661     -8110.8536     -8110.8536      338.5857       338.5857       24191.378      24191.378      564.09876      564.09876    
    107000  -8024.9112     -8024.9112     -8112.0073     -8112.0073      337.07098      337.07098      24172.402      24172.402      1653.413       1653.413     
Loop time of 150.389 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.775 hours/ns, 6.649 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.85     | 149.85     | 149.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097149   | 0.097149   | 0.097149   |   0.0 |  0.06
Output  | 0.0012722  | 0.0012722  | 0.0012722  |   0.0 |  0.00
Modify  | 0.37766    | 0.37766    | 0.37766    |   0.0 |  0.25
Other   |            | 0.0606     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205968 ave      205968 max      205968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205968
Ave neighs/atom = 102.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.587315718743, Press = -0.109330270963179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -8024.9112     -8024.9112     -8112.0073     -8112.0073      337.07098      337.07098      24172.402      24172.402      1653.413       1653.413     
    108000  -8023.7026     -8023.7026     -8110.2703     -8110.2703      335.02604      335.02604      24176.078      24176.078      1755.2416      1755.2416    
Loop time of 151.956 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.210 hours/ns, 6.581 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.41     | 151.41     | 151.41     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098561   | 0.098561   | 0.098561   |   0.0 |  0.06
Output  | 0.0001997  | 0.0001997  | 0.0001997  |   0.0 |  0.00
Modify  | 0.38639    | 0.38639    | 0.38639    |   0.0 |  0.25
Other   |            | 0.0617     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206662 ave      206662 max      206662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206662
Ave neighs/atom = 103.331
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.592592072404, Press = 0.184569326098311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -8023.7026     -8023.7026     -8110.2703     -8110.2703      335.02604      335.02604      24176.078      24176.078      1755.2416      1755.2416    
    109000  -8025.7152     -8025.7152     -8111.7934     -8111.7934      333.13173      333.13173      24191.464      24191.464      100.11942      100.11942    
Loop time of 150.764 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.879 hours/ns, 6.633 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.23     | 150.23     | 150.23     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096418   | 0.096418   | 0.096418   |   0.0 |  0.06
Output  | 0.0001637  | 0.0001637  | 0.0001637  |   0.0 |  0.00
Modify  | 0.38079    | 0.38079    | 0.38079    |   0.0 |  0.25
Other   |            | 0.06041    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206214 ave      206214 max      206214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206214
Ave neighs/atom = 103.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.575301978127, Press = 0.526310844988092
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -8025.7152     -8025.7152     -8111.7934     -8111.7934      333.13173      333.13173      24191.464      24191.464      100.11942      100.11942    
    110000  -8019.9259     -8019.9259     -8109.0431     -8109.0431      344.8927       344.8927       24217.019      24217.019     -1176.5475     -1176.5475    
Loop time of 153.549 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.653 hours/ns, 6.513 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153        | 153        | 153        |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098998   | 0.098998   | 0.098998   |   0.0 |  0.06
Output  | 0.00022125 | 0.00022125 | 0.00022125 |   0.0 |  0.00
Modify  | 0.38978    | 0.38978    | 0.38978    |   0.0 |  0.25
Other   |            | 0.06089    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206070 ave      206070 max      206070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206070
Ave neighs/atom = 103.035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.595293375381, Press = 0.503954651036424
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -8019.9259     -8019.9259     -8109.0431     -8109.0431      344.8927       344.8927       24217.019      24217.019     -1176.5475     -1176.5475    
    111000  -8027.0925     -8027.0925     -8113.3525     -8113.3525      333.83499      333.83499      24228.391      24228.391     -3106.1109     -3106.1109    
Loop time of 151.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.182 hours/ns, 6.585 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.32     | 151.32     | 151.32     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097096   | 0.097096   | 0.097096   |   0.0 |  0.06
Output  | 0.00018173 | 0.00018173 | 0.00018173 |   0.0 |  0.00
Modify  | 0.38261    | 0.38261    | 0.38261    |   0.0 |  0.25
Other   |            | 0.0603     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205312 ave      205312 max      205312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205312
Ave neighs/atom = 102.656
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.60514231014, Press = 0.261151878369365
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -8027.0925     -8027.0925     -8113.3525     -8113.3525      333.83499      333.83499      24228.391      24228.391     -3106.1109     -3106.1109    
    112000  -8025.2846     -8025.2846     -8112.055      -8112.055       335.81033      335.81033      24246.29       24246.29      -4288.4261     -4288.4261    
Loop time of 150.869 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.908 hours/ns, 6.628 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.33     | 150.33     | 150.33     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096939   | 0.096939   | 0.096939   |   0.0 |  0.06
Output  | 0.00016277 | 0.00016277 | 0.00016277 |   0.0 |  0.00
Modify  | 0.38104    | 0.38104    | 0.38104    |   0.0 |  0.25
Other   |            | 0.06059    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205364 ave      205364 max      205364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205364
Ave neighs/atom = 102.682
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.591017142643, Press = -0.438100480214591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -8025.2846     -8025.2846     -8112.055      -8112.055       335.81033      335.81033      24246.29       24246.29      -4288.4261     -4288.4261    
    113000  -8027.2933     -8027.2933     -8114.532      -8114.532       337.6228       337.6228       24204.877      24204.877     -1488.9686     -1488.9686    
Loop time of 149.927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.646 hours/ns, 6.670 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.39     | 149.39     | 149.39     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097756   | 0.097756   | 0.097756   |   0.0 |  0.07
Output  | 0.00016105 | 0.00016105 | 0.00016105 |   0.0 |  0.00
Modify  | 0.38179    | 0.38179    | 0.38179    |   0.0 |  0.25
Other   |            | 0.06032    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204760 ave      204760 max      204760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204760
Ave neighs/atom = 102.38
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.581196211714, Press = -0.500334855628054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -8027.2933     -8027.2933     -8114.532      -8114.532       337.6228       337.6228       24204.877      24204.877     -1488.9686     -1488.9686    
    114000  -8024.5983     -8024.5983     -8111.2528     -8111.2528      335.36195      335.36195      24191.005      24191.005      453.99483      453.99483    
Loop time of 148.618 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.283 hours/ns, 6.729 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.09     | 148.09     | 148.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095583   | 0.095583   | 0.095583   |   0.0 |  0.06
Output  | 0.0001637  | 0.0001637  | 0.0001637  |   0.0 |  0.00
Modify  | 0.37276    | 0.37276    | 0.37276    |   0.0 |  0.25
Other   |            | 0.06057    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206060 ave      206060 max      206060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206060
Ave neighs/atom = 103.03
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.549458191304, Press = -0.154475392111416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -8024.5983     -8024.5983     -8111.2528     -8111.2528      335.36195      335.36195      24191.005      24191.005      453.99483      453.99483    
    115000  -8026.4518     -8026.4518     -8113.4346     -8113.4346      336.63254      336.63254      24191.415      24191.415      62.736274      62.736274    
Loop time of 151.338 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.038 hours/ns, 6.608 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.8      | 150.8      | 150.8      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097639   | 0.097639   | 0.097639   |   0.0 |  0.06
Output  | 0.00016249 | 0.00016249 | 0.00016249 |   0.0 |  0.00
Modify  | 0.38321    | 0.38321    | 0.38321    |   0.0 |  0.25
Other   |            | 0.0604     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205978 ave      205978 max      205978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205978
Ave neighs/atom = 102.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.54490250946, Press = 0.0376571340563905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -8026.4518     -8026.4518     -8113.4346     -8113.4346      336.63254      336.63254      24191.415      24191.415      62.736274      62.736274    
    116000  -8022.545      -8022.545      -8111.2797     -8111.2797      343.41229      343.41229      24192.285      24192.285      490.63994      490.63994    
Loop time of 151.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.049 hours/ns, 6.606 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.84     | 150.84     | 150.84     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097437   | 0.097437   | 0.097437   |   0.0 |  0.06
Output  | 0.00017023 | 0.00017023 | 0.00017023 |   0.0 |  0.00
Modify  | 0.3825     | 0.3825     | 0.3825     |   0.0 |  0.25
Other   |            | 0.06052    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206090 ave      206090 max      206090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206090
Ave neighs/atom = 103.045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.567667966475, Press = 0.0651721903095856
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -8022.545      -8022.545      -8111.2797     -8111.2797      343.41229      343.41229      24192.285      24192.285      490.63994      490.63994    
    117000  -8025.8366     -8025.8366     -8111.6515     -8111.6515      332.11244      332.11244      24176          24176          1534.4434      1534.4434    
Loop time of 149.667 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.574 hours/ns, 6.682 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.13     | 149.13     | 149.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09666    | 0.09666    | 0.09666    |   0.0 |  0.06
Output  | 0.00017512 | 0.00017512 | 0.00017512 |   0.0 |  0.00
Modify  | 0.37822    | 0.37822    | 0.37822    |   0.0 |  0.25
Other   |            | 0.06076    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205868 ave      205868 max      205868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205868
Ave neighs/atom = 102.934
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.566428927106, Press = 0.0934930990682993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -8025.8366     -8025.8366     -8111.6515     -8111.6515      332.11244      332.11244      24176          24176          1534.4434      1534.4434    
    118000  -8024.5364     -8024.5364     -8109.4674     -8109.4674      328.69199      328.69199      24167.804      24167.804      2474.8202      2474.8202    
Loop time of 150.493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.804 hours/ns, 6.645 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.96     | 149.96     | 149.96     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097062   | 0.097062   | 0.097062   |   0.0 |  0.06
Output  | 0.00016275 | 0.00016275 | 0.00016275 |   0.0 |  0.00
Modify  | 0.3795     | 0.3795     | 0.3795     |   0.0 |  0.25
Other   |            | 0.06057    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206408 ave      206408 max      206408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206408
Ave neighs/atom = 103.204
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.559119413993, Press = 0.579367957792186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -8024.5364     -8024.5364     -8109.4674     -8109.4674      328.69199      328.69199      24167.804      24167.804      2474.8202      2474.8202    
    119000  -8026.9734     -8026.9734     -8111.402      -8111.402       326.74723      326.74723      24188.699      24188.699      461.61468      461.61468    
Loop time of 150.544 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.818 hours/ns, 6.643 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.01     | 150.01     | 150.01     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097087   | 0.097087   | 0.097087   |   0.0 |  0.06
Output  | 0.00016066 | 0.00016066 | 0.00016066 |   0.0 |  0.00
Modify  | 0.37882    | 0.37882    | 0.37882    |   0.0 |  0.25
Other   |            | 0.06058    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206430 ave      206430 max      206430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206430
Ave neighs/atom = 103.215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.55752789261, Press = 1.02120429654039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -8026.9734     -8026.9734     -8111.402      -8111.402       326.74723      326.74723      24188.699      24188.699      461.61468      461.61468    
    120000  -8024.1907     -8024.1907     -8110.3392     -8110.3392      333.40368      333.40368      24223.819      24223.819     -2021.8016     -2021.8016    
Loop time of 150.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.848 hours/ns, 6.638 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.11     | 150.11     | 150.11     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098253   | 0.098253   | 0.098253   |   0.0 |  0.07
Output  | 0.00028077 | 0.00028077 | 0.00028077 |   0.0 |  0.00
Modify  | 0.38459    | 0.38459    | 0.38459    |   0.0 |  0.26
Other   |            | 0.06063    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206166 ave      206166 max      206166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206166
Ave neighs/atom = 103.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.577479169206, Press = 0.471570608387425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -8024.1907     -8024.1907     -8110.3392     -8110.3392      333.40368      333.40368      24223.819      24223.819     -2021.8016     -2021.8016    
    121000  -8022.2118     -8022.2118     -8109.1267     -8109.1267      336.3696       336.3696       24215.714      24215.714     -1016.5658     -1016.5658    
Loop time of 149.971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.659 hours/ns, 6.668 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.43     | 149.43     | 149.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09692    | 0.09692    | 0.09692    |   0.0 |  0.06
Output  | 0.00016357 | 0.00016357 | 0.00016357 |   0.0 |  0.00
Modify  | 0.37962    | 0.37962    | 0.37962    |   0.0 |  0.25
Other   |            | 0.06081    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205438 ave      205438 max      205438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205438
Ave neighs/atom = 102.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.584339192236, Press = -0.000821092629701412
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -8022.2118     -8022.2118     -8109.1267     -8109.1267      336.3696       336.3696       24215.714      24215.714     -1016.5658     -1016.5658    
    122000  -8026.7347     -8026.7347     -8110.9862     -8110.9862      326.06229      326.06229      24194.319      24194.319      215.6979       215.6979     
Loop time of 150.163 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.712 hours/ns, 6.659 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.63     | 149.63     | 149.63     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096615   | 0.096615   | 0.096615   |   0.0 |  0.06
Output  | 0.00016053 | 0.00016053 | 0.00016053 |   0.0 |  0.00
Modify  | 0.3801     | 0.3801     | 0.3801     |   0.0 |  0.25
Other   |            | 0.06015    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205248 ave      205248 max      205248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205248
Ave neighs/atom = 102.624
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.602413231433, Press = 0.121298765075874
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -8026.7347     -8026.7347     -8110.9862     -8110.9862      326.06229      326.06229      24194.319      24194.319      215.6979       215.6979     
    123000  -8023.3439     -8023.3439     -8111.2317     -8111.2317      340.13467      340.13467      24202.75       24202.75      -373.04939     -373.04939    
Loop time of 148.934 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.371 hours/ns, 6.714 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.4      | 148.4      | 148.4      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096096   | 0.096096   | 0.096096   |   0.0 |  0.06
Output  | 0.00016353 | 0.00016353 | 0.00016353 |   0.0 |  0.00
Modify  | 0.37424    | 0.37424    | 0.37424    |   0.0 |  0.25
Other   |            | 0.05932    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206130 ave      206130 max      206130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206130
Ave neighs/atom = 103.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.603340079854, Press = 0.0368360751866968
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -8023.3439     -8023.3439     -8111.2317     -8111.2317      340.13467      340.13467      24202.75       24202.75      -373.04939     -373.04939    
    124000  -8028.193      -8028.193      -8113.7681     -8113.7681      331.18426      331.18426      24187.728      24187.728      110.34169      110.34169    
Loop time of 149.963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.656 hours/ns, 6.668 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.43     | 149.43     | 149.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097274   | 0.097274   | 0.097274   |   0.0 |  0.06
Output  | 0.00016403 | 0.00016403 | 0.00016403 |   0.0 |  0.00
Modify  | 0.3794     | 0.3794     | 0.3794     |   0.0 |  0.25
Other   |            | 0.05994    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205892 ave      205892 max      205892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205892
Ave neighs/atom = 102.946
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.593449458235, Press = -0.0647000395105463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -8028.193      -8028.193      -8113.7681     -8113.7681      331.18426      331.18426      24187.728      24187.728      110.34169      110.34169    
    125000  -8024.358      -8024.358      -8111.24       -8111.24        336.24216      336.24216      24179.203      24179.203      1281.6785      1281.6785    
Loop time of 149.632 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.564 hours/ns, 6.683 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.1      | 149.1      | 149.1      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095947   | 0.095947   | 0.095947   |   0.0 |  0.06
Output  | 0.00025828 | 0.00025828 | 0.00025828 |   0.0 |  0.00
Modify  | 0.37482    | 0.37482    | 0.37482    |   0.0 |  0.25
Other   |            | 0.06001    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206232 ave      206232 max      206232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206232
Ave neighs/atom = 103.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.578198435215, Press = -0.188392433698316
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -8024.358      -8024.358      -8111.24       -8111.24        336.24216      336.24216      24179.203      24179.203      1281.6785      1281.6785    
    126000  -8025.4683     -8025.4683     -8109.8591     -8109.8591      326.60129      326.60129      24163.622      24163.622      2758.4402      2758.4402    
Loop time of 148.384 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.218 hours/ns, 6.739 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.85     | 147.85     | 147.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096428   | 0.096428   | 0.096428   |   0.0 |  0.06
Output  | 0.00016144 | 0.00016144 | 0.00016144 |   0.0 |  0.00
Modify  | 0.37323    | 0.37323    | 0.37323    |   0.0 |  0.25
Other   |            | 0.05974    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206262 ave      206262 max      206262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206262
Ave neighs/atom = 103.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.550837564027, Press = 0.210676657786917
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -8025.4683     -8025.4683     -8109.8591     -8109.8591      326.60129      326.60129      24163.622      24163.622      2758.4402      2758.4402    
    127000  -8023.477      -8023.477      -8109.5767     -8109.5767      333.21462      333.21462      24160.993      24160.993      3095.6064      3095.6064    
Loop time of 149.007 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.391 hours/ns, 6.711 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.48     | 148.48     | 148.48     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096044   | 0.096044   | 0.096044   |   0.0 |  0.06
Output  | 0.00016315 | 0.00016315 | 0.00016315 |   0.0 |  0.00
Modify  | 0.37529    | 0.37529    | 0.37529    |   0.0 |  0.25
Other   |            | 0.05998    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206574 ave      206574 max      206574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206574
Ave neighs/atom = 103.287
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.538718625968, Press = 0.566148118367952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -8023.477      -8023.477      -8109.5767     -8109.5767      333.21462      333.21462      24160.993      24160.993      3095.6064      3095.6064    
    128000  -8025.5945     -8025.5945     -8111.0185     -8111.0185      330.59969      330.59969      24175.658      24175.658      1698.183       1698.183     
Loop time of 149.578 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.550 hours/ns, 6.685 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.05     | 149.05     | 149.05     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096759   | 0.096759   | 0.096759   |   0.0 |  0.06
Output  | 0.00016523 | 0.00016523 | 0.00016523 |   0.0 |  0.00
Modify  | 0.3747     | 0.3747     | 0.3747     |   0.0 |  0.25
Other   |            | 0.05983    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206620 ave      206620 max      206620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206620
Ave neighs/atom = 103.31
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.528425309582, Press = 0.875401435835879
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -8025.5945     -8025.5945     -8111.0185     -8111.0185      330.59969      330.59969      24175.658      24175.658      1698.183       1698.183     
    129000  -8021.3178     -8021.3178     -8110.1845     -8110.1845      343.92307      343.92307      24210.872      24210.872     -1018.8293     -1018.8293    
Loop time of 149.645 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.568 hours/ns, 6.682 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.11     | 149.11     | 149.11     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096856   | 0.096856   | 0.096856   |   0.0 |  0.06
Output  | 0.00016183 | 0.00016183 | 0.00016183 |   0.0 |  0.00
Modify  | 0.37527    | 0.37527    | 0.37527    |   0.0 |  0.25
Other   |            | 0.06003    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206294 ave      206294 max      206294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206294
Ave neighs/atom = 103.147
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.527461429729, Press = 0.327306219959295
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -8021.3178     -8021.3178     -8110.1845     -8110.1845      343.92307      343.92307      24210.872      24210.872     -1018.8293     -1018.8293    
    130000  -8027.1341     -8027.1341     -8110.9664     -8110.9664      324.43991      324.43991      24206.375      24206.375     -855.44077     -855.44077    
Loop time of 149.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.464 hours/ns, 6.699 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.73     | 148.73     | 148.73     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09628    | 0.09628    | 0.09628    |   0.0 |  0.06
Output  | 0.00016263 | 0.00016263 | 0.00016263 |   0.0 |  0.00
Modify  | 0.37812    | 0.37812    | 0.37812    |   0.0 |  0.25
Other   |            | 0.06071    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205396 ave      205396 max      205396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205396
Ave neighs/atom = 102.698
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.53184071697, Press = 0.17009183920434
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -8027.1341     -8027.1341     -8110.9664     -8110.9664      324.43991      324.43991      24206.375      24206.375     -855.44077     -855.44077    
    131000  -8026.8939     -8026.8939     -8110.6474     -8110.6474      324.13492      324.13492      24203.701      24203.701     -518.07204     -518.07204    
Loop time of 149.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.630 hours/ns, 6.673 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.34     | 149.34     | 149.34     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09672    | 0.09672    | 0.09672    |   0.0 |  0.06
Output  | 0.00016335 | 0.00016335 | 0.00016335 |   0.0 |  0.00
Modify  | 0.37564    | 0.37564    | 0.37564    |   0.0 |  0.25
Other   |            | 0.05952    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205700 ave      205700 max      205700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205700
Ave neighs/atom = 102.85
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.529318138015, Press = -0.0277257623646209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -8026.8939     -8026.8939     -8110.6474     -8110.6474      324.13492      324.13492      24203.701      24203.701     -518.07204     -518.07204    
    132000  -8024.0861     -8024.0861     -8112.3642     -8112.3642      341.64511      341.64511      24219.207      24219.207     -2057.0125     -2057.0125    
Loop time of 150.217 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.727 hours/ns, 6.657 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.68     | 149.68     | 149.68     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096438   | 0.096438   | 0.096438   |   0.0 |  0.06
Output  | 0.00024134 | 0.00024134 | 0.00024134 |   0.0 |  0.00
Modify  | 0.38014    | 0.38014    | 0.38014    |   0.0 |  0.25
Other   |            | 0.0608     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205618 ave      205618 max      205618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205618
Ave neighs/atom = 102.809
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.510851976448, Press = -0.178520134533198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -8024.0861     -8024.0861     -8112.3642     -8112.3642      341.64511      341.64511      24219.207      24219.207     -2057.0125     -2057.0125    
    133000  -8023.8072     -8023.8072     -8110.7211     -8110.7211      336.36571      336.36571      24212.197      24212.197     -1103.8965     -1103.8965    
Loop time of 150.761 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.878 hours/ns, 6.633 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.22     | 150.22     | 150.22     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096873   | 0.096873   | 0.096873   |   0.0 |  0.06
Output  | 0.00016649 | 0.00016649 | 0.00016649 |   0.0 |  0.00
Modify  | 0.38076    | 0.38076    | 0.38076    |   0.0 |  0.25
Other   |            | 0.06026    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205604 ave      205604 max      205604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205604
Ave neighs/atom = 102.802
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.527014404492, Press = -0.475635721552827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -8023.8072     -8023.8072     -8110.7211     -8110.7211      336.36571      336.36571      24212.197      24212.197     -1103.8965     -1103.8965    
    134000  -8026.2549     -8026.2549     -8112.1694     -8112.1694      332.49771      332.49771      24183.182      24183.182      814.10432      814.10432    
Loop time of 149.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.411 hours/ns, 6.708 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.55     | 148.55     | 148.55     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095901   | 0.095901   | 0.095901   |   0.0 |  0.06
Output  | 0.00016329 | 0.00016329 | 0.00016329 |   0.0 |  0.00
Modify  | 0.37506    | 0.37506    | 0.37506    |   0.0 |  0.25
Other   |            | 0.06033    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205526 ave      205526 max      205526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205526
Ave neighs/atom = 102.763
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.532653809611, Press = -0.434313250707338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -8026.2549     -8026.2549     -8112.1694     -8112.1694      332.49771      332.49771      24183.182      24183.182      814.10432      814.10432    
    135000  -8026.817      -8026.817      -8111.1974     -8111.1974      326.5609       326.5609       24163.793      24163.793      2498.3819      2498.3819    
Loop time of 148.363 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.212 hours/ns, 6.740 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.84     | 147.84     | 147.84     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09473    | 0.09473    | 0.09473    |   0.0 |  0.06
Output  | 0.0001649  | 0.0001649  | 0.0001649  |   0.0 |  0.00
Modify  | 0.37217    | 0.37217    | 0.37217    |   0.0 |  0.25
Other   |            | 0.05999    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206248 ave      206248 max      206248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206248
Ave neighs/atom = 103.124
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.536934734311, Press = -0.313555942746468
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -8026.817      -8026.817      -8111.1974     -8111.1974      326.5609       326.5609       24163.793      24163.793      2498.3819      2498.3819    
    136000  -8025.5591     -8025.5591     -8112.0387     -8112.0387      334.68477      334.68477      24149.31       24149.31       3492.1801      3492.1801    
Loop time of 149.024 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.396 hours/ns, 6.710 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.49     | 148.49     | 148.49     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09576    | 0.09576    | 0.09576    |   0.0 |  0.06
Output  | 0.00025492 | 0.00025492 | 0.00025492 |   0.0 |  0.00
Modify  | 0.37277    | 0.37277    | 0.37277    |   0.0 |  0.25
Other   |            | 0.06013    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206450 ave      206450 max      206450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206450
Ave neighs/atom = 103.225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.508818128786, Press = 0.207701354305761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -8025.5591     -8025.5591     -8112.0387     -8112.0387      334.68477      334.68477      24149.31       24149.31       3492.1801      3492.1801    
    137000  -8023.6484     -8023.6484     -8111.712      -8111.712       340.8151       340.8151       24153.274      24153.274      3357.1192      3357.1192    
Loop time of 150.234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.732 hours/ns, 6.656 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.7      | 149.7      | 149.7      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096675   | 0.096675   | 0.096675   |   0.0 |  0.06
Output  | 0.00016269 | 0.00016269 | 0.00016269 |   0.0 |  0.00
Modify  | 0.37606    | 0.37606    | 0.37606    |   0.0 |  0.25
Other   |            | 0.0598     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207080 ave      207080 max      207080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207080
Ave neighs/atom = 103.54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.514179868138, Press = 0.824972522199388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -8023.6484     -8023.6484     -8111.712      -8111.712       340.8151       340.8151       24153.274      24153.274      3357.1192      3357.1192    
    138000  -8024.6064     -8024.6064     -8111.2829     -8111.2829      335.44666      335.44666      24199.697      24199.697     -120.87491     -120.87491    
Loop time of 151.694 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.137 hours/ns, 6.592 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.15     | 151.15     | 151.15     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097932   | 0.097932   | 0.097932   |   0.0 |  0.06
Output  | 0.00016452 | 0.00016452 | 0.00016452 |   0.0 |  0.00
Modify  | 0.38353    | 0.38353    | 0.38353    |   0.0 |  0.25
Other   |            | 0.06042    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206910 ave      206910 max      206910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206910
Ave neighs/atom = 103.455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.508421381714, Press = 0.554368737402195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -8024.6064     -8024.6064     -8111.2829     -8111.2829      335.44666      335.44666      24199.697      24199.697     -120.87491     -120.87491    
    139000  -8022.1904     -8022.1904     -8109.6601     -8109.6601      338.51675      338.51675      24219.824      24219.824     -1408.7083     -1408.7083    
Loop time of 148.43 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.231 hours/ns, 6.737 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.9      | 147.9      | 147.9      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094921   | 0.094921   | 0.094921   |   0.0 |  0.06
Output  | 0.0002728  | 0.0002728  | 0.0002728  |   0.0 |  0.00
Modify  | 0.37355    | 0.37355    | 0.37355    |   0.0 |  0.25
Other   |            | 0.05974    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205980 ave      205980 max      205980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205980
Ave neighs/atom = 102.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.530192125903, Press = 0.316053773572747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -8022.1904     -8022.1904     -8109.6601     -8109.6601      338.51675      338.51675      24219.824      24219.824     -1408.7083     -1408.7083    
    140000  -8026.8741     -8026.8741     -8112.1047     -8112.1047      329.85125      329.85125      24214.645      24214.645     -1669.1404     -1669.1404    
Loop time of 149.969 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.658 hours/ns, 6.668 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.43     | 149.43     | 149.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097493   | 0.097493   | 0.097493   |   0.0 |  0.07
Output  | 0.00020322 | 0.00020322 | 0.00020322 |   0.0 |  0.00
Modify  | 0.37802    | 0.37802    | 0.37802    |   0.0 |  0.25
Other   |            | 0.06045    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205378 ave      205378 max      205378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205378
Ave neighs/atom = 102.689
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.529450996191, Press = 0.0208295219918795
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -8026.8741     -8026.8741     -8112.1047     -8112.1047      329.85125      329.85125      24214.645      24214.645     -1669.1404     -1669.1404    
    141000  -8022.0646     -8022.0646     -8109.3382     -8109.3382      337.75774      337.75774      24228.193      24228.193     -2039.1683     -2039.1683    
Loop time of 147.795 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.054 hours/ns, 6.766 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.27     | 147.27     | 147.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095454   | 0.095454   | 0.095454   |   0.0 |  0.06
Output  | 0.00016227 | 0.00016227 | 0.00016227 |   0.0 |  0.00
Modify  | 0.37315    | 0.37315    | 0.37315    |   0.0 |  0.25
Other   |            | 0.05955    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205518 ave      205518 max      205518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205518
Ave neighs/atom = 102.759
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.52746508025, Press = -0.129201488746339
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -8022.0646     -8022.0646     -8109.3382     -8109.3382      337.75774      337.75774      24228.193      24228.193     -2039.1683     -2039.1683    
    142000  -8026.304      -8026.304      -8112.2328     -8112.2328      332.55317      332.55317      24223.906      24223.906     -2327.1721     -2327.1721    
Loop time of 150.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.794 hours/ns, 6.646 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.92     | 149.92     | 149.92     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096215   | 0.096215   | 0.096215   |   0.0 |  0.06
Output  | 0.00016205 | 0.00016205 | 0.00016205 |   0.0 |  0.00
Modify  | 0.37994    | 0.37994    | 0.37994    |   0.0 |  0.25
Other   |            | 0.06046    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205340 ave      205340 max      205340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205340
Ave neighs/atom = 102.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.52503570135, Press = -0.942527162428955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -8026.304      -8026.304      -8112.2328     -8112.2328      332.55317      332.55317      24223.906      24223.906     -2327.1721     -2327.1721    
    143000  -8023.6029     -8023.6029     -8109.712      -8109.712       333.25124      333.25124      24184.49       24184.49       1382.7607      1382.7607    
Loop time of 149.141 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.428 hours/ns, 6.705 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.61     | 148.61     | 148.61     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096369   | 0.096369   | 0.096369   |   0.0 |  0.06
Output  | 0.00021078 | 0.00021078 | 0.00021078 |   0.0 |  0.00
Modify  | 0.37603    | 0.37603    | 0.37603    |   0.0 |  0.25
Other   |            | 0.06048    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205480 ave      205480 max      205480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205480
Ave neighs/atom = 102.74
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.498412521408, Press = -0.499465838123525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -8023.6029     -8023.6029     -8109.712      -8109.712       333.25124      333.25124      24184.49       24184.49       1382.7607      1382.7607    
    144000  -8025.6861     -8025.6861     -8110.587      -8110.587       328.57532      328.57532      24166.161      24166.161      2244.1505      2244.1505    
Loop time of 149.385 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.496 hours/ns, 6.694 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.85     | 148.85     | 148.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096452   | 0.096452   | 0.096452   |   0.0 |  0.06
Output  | 0.00016449 | 0.00016449 | 0.00016449 |   0.0 |  0.00
Modify  | 0.37436    | 0.37436    | 0.37436    |   0.0 |  0.25
Other   |            | 0.05995    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206162 ave      206162 max      206162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206162
Ave neighs/atom = 103.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.498177834623, Press = -0.0278567176991026
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -8025.6861     -8025.6861     -8110.587      -8110.587       328.57532      328.57532      24166.161      24166.161      2244.1505      2244.1505    
    145000  -8020.2571     -8020.2571     -8110.2966     -8110.2966      348.46209      348.46209      24180.457      24180.457      1395.5258      1395.5258    
Loop time of 148.829 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.342 hours/ns, 6.719 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.3      | 148.3      | 148.3      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095808   | 0.095808   | 0.095808   |   0.0 |  0.06
Output  | 0.00019874 | 0.00019874 | 0.00019874 |   0.0 |  0.00
Modify  | 0.37305    | 0.37305    | 0.37305    |   0.0 |  0.25
Other   |            | 0.06005    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206408 ave      206408 max      206408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206408
Ave neighs/atom = 103.204
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.516194423571, Press = 0.292677462494054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -8020.2571     -8020.2571     -8110.2966     -8110.2966      348.46209      348.46209      24180.457      24180.457      1395.5258      1395.5258    
    146000  -8023.6213     -8023.6213     -8110.5118     -8110.5118      336.2751       336.2751       24177.735      24177.735      1524.5435      1524.5435    
Loop time of 151.031 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.953 hours/ns, 6.621 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.49     | 150.49     | 150.49     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0968     | 0.0968     | 0.0968     |   0.0 |  0.06
Output  | 0.00019773 | 0.00019773 | 0.00019773 |   0.0 |  0.00
Modify  | 0.37993    | 0.37993    | 0.37993    |   0.0 |  0.25
Other   |            | 0.06025    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206338 ave      206338 max      206338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206338
Ave neighs/atom = 103.169
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.515336346149, Press = 0.620113312581102
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    146000  -8023.6213     -8023.6213     -8110.5118     -8110.5118      336.2751       336.2751       24177.735      24177.735      1524.5435      1524.5435    
    147000  -8025.2325     -8025.2325     -8110.7951     -8110.7951      331.13619      331.13619      24193.547      24193.547      371.57243      371.57243    
Loop time of 149.981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.661 hours/ns, 6.668 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.45     | 149.45     | 149.45     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096592   | 0.096592   | 0.096592   |   0.0 |  0.06
Output  | 0.00016323 | 0.00016323 | 0.00016323 |   0.0 |  0.00
Modify  | 0.37348    | 0.37348    | 0.37348    |   0.0 |  0.25
Other   |            | 0.06016    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206494 ave      206494 max      206494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206494
Ave neighs/atom = 103.247
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.534190956827, Press = 0.543636565617602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    147000  -8025.2325     -8025.2325     -8110.7951     -8110.7951      331.13619      331.13619      24193.547      24193.547      371.57243      371.57243    
    148000  -8022.5237     -8022.5237     -8109.2761     -8109.2761      335.74073      335.74073      24235.354      24235.354     -2850.3988     -2850.3988    
Loop time of 152.632 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.398 hours/ns, 6.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    | 152.09     | 152.09     | 152.09     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097367   | 0.097367   | 0.097367   |   0.0 |  0.06
Output  | 0.00016285 | 0.00016285 | 0.00016285 |   0.0 |  0.00
Modify  | 0.38514    | 0.38514    | 0.38514    |   0.0 |  0.25
Other   |            | 0.06125    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206060 ave      206060 max      206060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206060
Ave neighs/atom = 103.03
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.543613724828, Press = 0.635353225268041
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    148000  -8022.5237     -8022.5237     -8109.2761     -8109.2761      335.74073      335.74073      24235.354      24235.354     -2850.3988     -2850.3988    
    149000  -8026.963      -8026.963      -8110.6369     -8110.6369      323.82645      323.82645      24240.556      24240.556     -3494.9741     -3494.9741    
Loop time of 149.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.511 hours/ns, 6.692 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.91     | 148.91     | 148.91     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096019   | 0.096019   | 0.096019   |   0.0 |  0.06
Output  | 0.00016298 | 0.00016298 | 0.00016298 |   0.0 |  0.00
Modify  | 0.37801    | 0.37801    | 0.37801    |   0.0 |  0.25
Other   |            | 0.06073    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205106 ave      205106 max      205106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205106
Ave neighs/atom = 102.553
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.544077267647, Press = 0.168670675929573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    149000  -8026.963      -8026.963      -8110.6369     -8110.6369      323.82645      323.82645      24240.556      24240.556     -3494.9741     -3494.9741    
    150000  -8019.6717     -8019.6717     -8108.5852     -8108.5852      344.10442      344.10442      24222.469      24222.469     -1392.221      -1392.221     
Loop time of 149.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.409 hours/ns, 6.708 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.54     | 148.54     | 148.54     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095547   | 0.095547   | 0.095547   |   0.0 |  0.06
Output  | 0.00016189 | 0.00016189 | 0.00016189 |   0.0 |  0.00
Modify  | 0.37552    | 0.37552    | 0.37552    |   0.0 |  0.25
Other   |            | 0.06018    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205154 ave      205154 max      205154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205154
Ave neighs/atom = 102.577
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.558627320655, Press = 0.0307623242428669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    150000  -8019.6717     -8019.6717     -8108.5852     -8108.5852      344.10442      344.10442      24222.469      24222.469     -1392.221      -1392.221     
    151000  -8026.5625     -8026.5625     -8113.287      -8113.287       335.63267      335.63267      24198.865      24198.865     -765.50498     -765.50498    
Loop time of 151.598 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.110 hours/ns, 6.596 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.06     | 151.06     | 151.06     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0977     | 0.0977     | 0.0977     |   0.0 |  0.06
Output  | 0.00016546 | 0.00016546 | 0.00016546 |   0.0 |  0.00
Modify  | 0.38152    | 0.38152    | 0.38152    |   0.0 |  0.25
Other   |            | 0.06015    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205352 ave      205352 max      205352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205352
Ave neighs/atom = 102.676
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.561177020647, Press = 0.0186124089395652
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    151000  -8026.5625     -8026.5625     -8113.287      -8113.287       335.63267      335.63267      24198.865      24198.865     -765.50498     -765.50498    
    152000  -8020.8216     -8020.8216     -8107.2805     -8107.2805      334.60473      334.60473      24196.742      24196.742      554.71903      554.71903    
Loop time of 155.006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.557 ns/day, 43.057 hours/ns, 6.451 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.45     | 154.45     | 154.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099704   | 0.099704   | 0.099704   |   0.0 |  0.06
Output  | 0.00016138 | 0.00016138 | 0.00016138 |   0.0 |  0.00
Modify  | 0.39493    | 0.39493    | 0.39493    |   0.0 |  0.25
Other   |            | 0.06218    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206044 ave      206044 max      206044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206044
Ave neighs/atom = 103.022
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.574632347308, Press = -0.0261194386866553
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    152000  -8020.8216     -8020.8216     -8107.2805     -8107.2805      334.60473      334.60473      24196.742      24196.742      554.71903      554.71903    
    153000  -8027.632      -8027.632      -8113.9034     -8113.9034      333.87923      333.87923      24155.01       24155.01       2711.5559      2711.5559    
Loop time of 148.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.352 hours/ns, 6.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    | 148.33     | 148.33     | 148.33     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096876   | 0.096876   | 0.096876   |   0.0 |  0.07
Output  | 0.00016339 | 0.00016339 | 0.00016339 |   0.0 |  0.00
Modify  | 0.37607    | 0.37607    | 0.37607    |   0.0 |  0.25
Other   |            | 0.06028    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205802 ave      205802 max      205802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205802
Ave neighs/atom = 102.901
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.580584523027, Press = -0.03783718116433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    153000  -8027.632      -8027.632      -8113.9034     -8113.9034      333.87923      333.87923      24155.01       24155.01       2711.5559      2711.5559    
    154000  -8024.4292     -8024.4292     -8112.3881     -8112.3881      340.41         340.41         24149.844      24149.844      3428.8877      3428.8877    
Loop time of 150.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.850 hours/ns, 6.637 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.13     | 150.13     | 150.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096336   | 0.096336   | 0.096336   |   0.0 |  0.06
Output  | 0.00016344 | 0.00016344 | 0.00016344 |   0.0 |  0.00
Modify  | 0.37797    | 0.37797    | 0.37797    |   0.0 |  0.25
Other   |            | 0.06038    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206858 ave      206858 max      206858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206858
Ave neighs/atom = 103.429
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.586640534802, Press = 0.341031204508142
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    154000  -8024.4292     -8024.4292     -8112.3881     -8112.3881      340.41         340.41         24149.844      24149.844      3428.8877      3428.8877    
    155000  -8023.8694     -8023.8694     -8112.8816     -8112.8816      344.48635      344.48635      24177.501      24177.501      1151.4119      1151.4119    
Loop time of 154.554 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.559 ns/day, 42.932 hours/ns, 6.470 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154        | 154        | 154        |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098747   | 0.098747   | 0.098747   |   0.0 |  0.06
Output  | 0.00020192 | 0.00020192 | 0.00020192 |   0.0 |  0.00
Modify  | 0.38868    | 0.38868    | 0.38868    |   0.0 |  0.25
Other   |            | 0.06134    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206956 ave      206956 max      206956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206956
Ave neighs/atom = 103.478
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.591565019672, Press = 0.589257514043946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    155000  -8023.8694     -8023.8694     -8112.8816     -8112.8816      344.48635      344.48635      24177.501      24177.501      1151.4119      1151.4119    
    156000  -8030.2416     -8030.2416     -8115.0041     -8115.0041      328.03981      328.03981      24189.076      24189.076     -433.33525     -433.33525    
Loop time of 150.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.833 hours/ns, 6.640 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.06     | 150.06     | 150.06     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097212   | 0.097212   | 0.097212   |   0.0 |  0.06
Output  | 0.0001645  | 0.0001645  | 0.0001645  |   0.0 |  0.00
Modify  | 0.3778     | 0.3778     | 0.3778     |   0.0 |  0.25
Other   |            | 0.06079    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206386 ave      206386 max      206386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206386
Ave neighs/atom = 103.193
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.587306821235, Press = 0.452793715480176
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    156000  -8030.2416     -8030.2416     -8115.0041     -8115.0041      328.03981      328.03981      24189.076      24189.076     -433.33525     -433.33525    
    157000  -8024.3421     -8024.3421     -8111.4743     -8111.4743      337.21039      337.21039      24207.119      24207.119     -949.47119     -949.47119    
Loop time of 150.707 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.863 hours/ns, 6.635 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.17     | 150.17     | 150.17     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097536   | 0.097536   | 0.097536   |   0.0 |  0.06
Output  | 0.00020891 | 0.00020891 | 0.00020891 |   0.0 |  0.00
Modify  | 0.38065    | 0.38065    | 0.38065    |   0.0 |  0.25
Other   |            | 0.06104    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206280 ave      206280 max      206280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206280
Ave neighs/atom = 103.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.572715553862, Press = 0.226678032098153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    157000  -8024.3421     -8024.3421     -8111.4743     -8111.4743      337.21039      337.21039      24207.119      24207.119     -949.47119     -949.47119    
    158000  -8026.1197     -8026.1197     -8113.3294     -8113.3294      337.51062      337.51062      24206.69       24206.69      -1249.9418     -1249.9418    
Loop time of 152.533 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.370 hours/ns, 6.556 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.99     | 151.99     | 151.99     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09757    | 0.09757    | 0.09757    |   0.0 |  0.06
Output  | 0.00016564 | 0.00016564 | 0.00016564 |   0.0 |  0.00
Modify  | 0.38611    | 0.38611    | 0.38611    |   0.0 |  0.25
Other   |            | 0.06069    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205724 ave      205724 max      205724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205724
Ave neighs/atom = 102.862
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.569465814256, Press = 0.102210734953807
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    158000  -8026.1197     -8026.1197     -8113.3294     -8113.3294      337.51062      337.51062      24206.69       24206.69      -1249.9418     -1249.9418    
    159000  -8024.7046     -8024.7046     -8108.9367     -8108.9367      325.98703      325.98703      24197.166      24197.166      415.79836      415.79836    
Loop time of 150.145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.707 hours/ns, 6.660 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.61     | 149.61     | 149.61     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096138   | 0.096138   | 0.096138   |   0.0 |  0.06
Output  | 0.00016274 | 0.00016274 | 0.00016274 |   0.0 |  0.00
Modify  | 0.37921    | 0.37921    | 0.37921    |   0.0 |  0.25
Other   |            | 0.06031    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205876 ave      205876 max      205876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205876
Ave neighs/atom = 102.938
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.570750928496, Press = -0.0867399183438603
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    159000  -8024.7046     -8024.7046     -8108.9367     -8108.9367      325.98703      325.98703      24197.166      24197.166      415.79836      415.79836    
    160000  -8022.7648     -8022.7648     -8110.8746     -8110.8746      340.9939       340.9939       24194.571      24194.571      359.8777       359.8777     
Loop time of 150.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.764 hours/ns, 6.651 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.82     | 149.82     | 149.82     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096973   | 0.096973   | 0.096973   |   0.0 |  0.06
Output  | 0.00022793 | 0.00022793 | 0.00022793 |   0.0 |  0.00
Modify  | 0.37883    | 0.37883    | 0.37883    |   0.0 |  0.25
Other   |            | 0.06012    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205950 ave      205950 max      205950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205950
Ave neighs/atom = 102.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.56906025444, Press = -0.09509096528022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    160000  -8022.7648     -8022.7648     -8110.8746     -8110.8746      340.9939       340.9939       24194.571      24194.571      359.8777       359.8777     
    161000  -8024.2869     -8024.2869     -8110.3344     -8110.3344      333.01277      333.01277      24163.012      24163.012      2886.3631      2886.3631    
Loop time of 151.067 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.963 hours/ns, 6.620 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.52     | 150.52     | 150.52     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097846   | 0.097846   | 0.097846   |   0.0 |  0.06
Output  | 0.00016384 | 0.00016384 | 0.00016384 |   0.0 |  0.00
Modify  | 0.3829     | 0.3829     | 0.3829     |   0.0 |  0.25
Other   |            | 0.06097    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205932 ave      205932 max      205932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205932
Ave neighs/atom = 102.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.592584385594, Press = -0.180707114369704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    161000  -8024.2869     -8024.2869     -8110.3344     -8110.3344      333.01277      333.01277      24163.012      24163.012      2886.3631      2886.3631    
    162000  -8023.0593     -8023.0593     -8110.197      -8110.197       337.23198      337.23198      24156.412      24156.412      3447.9011      3447.9011    
Loop time of 150.664 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.851 hours/ns, 6.637 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.13     | 150.13     | 150.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096368   | 0.096368   | 0.096368   |   0.0 |  0.06
Output  | 0.00016369 | 0.00016369 | 0.00016369 |   0.0 |  0.00
Modify  | 0.38018    | 0.38018    | 0.38018    |   0.0 |  0.25
Other   |            | 0.06046    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206700 ave      206700 max      206700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206700
Ave neighs/atom = 103.35
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.593585324082, Press = 0.23718805921986
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    162000  -8023.0593     -8023.0593     -8110.197      -8110.197       337.23198      337.23198      24156.412      24156.412      3447.9011      3447.9011    
    163000  -8024.1884     -8024.1884     -8110.7011     -8110.7011      334.81295      334.81295      24170.569      24170.569      2280.6145      2280.6145    
Loop time of 149.18 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.439 hours/ns, 6.703 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.65     | 148.65     | 148.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095543   | 0.095543   | 0.095543   |   0.0 |  0.06
Output  | 0.00016308 | 0.00016308 | 0.00016308 |   0.0 |  0.00
Modify  | 0.37453    | 0.37453    | 0.37453    |   0.0 |  0.25
Other   |            | 0.05976    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206674 ave      206674 max      206674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206674
Ave neighs/atom = 103.337
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.604678780557, Press = 0.407285968027446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    163000  -8024.1884     -8024.1884     -8110.7011     -8110.7011      334.81295      334.81295      24170.569      24170.569      2280.6145      2280.6145    
    164000  -8025.0897     -8025.0897     -8110.9146     -8110.9146      332.15147      332.15147      24196.877      24196.877     -14.867745     -14.867745    
Loop time of 149.228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.452 hours/ns, 6.701 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.7      | 148.7      | 148.7      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096633   | 0.096633   | 0.096633   |   0.0 |  0.06
Output  | 0.00016346 | 0.00016346 | 0.00016346 |   0.0 |  0.00
Modify  | 0.37422    | 0.37422    | 0.37422    |   0.0 |  0.25
Other   |            | 0.05984    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206490 ave      206490 max      206490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206490
Ave neighs/atom = 103.245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.606857949563, Press = 0.369773913647761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    164000  -8025.0897     -8025.0897     -8110.9146     -8110.9146      332.15147      332.15147      24196.877      24196.877     -14.867745     -14.867745    
    165000  -8022.4977     -8022.4977     -8109.8468     -8109.8468      338.0501       338.0501       24214.793      24214.793     -1096.1387     -1096.1387    
Loop time of 148.372 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.84     | 147.84     | 147.84     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095388   | 0.095388   | 0.095388   |   0.0 |  0.06
Output  | 0.00016476 | 0.00016476 | 0.00016476 |   0.0 |  0.00
Modify  | 0.37228    | 0.37228    | 0.37228    |   0.0 |  0.25
Other   |            | 0.06053    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206022 ave      206022 max      206022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206022
Ave neighs/atom = 103.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.617467798261, Press = 0.173147788908255
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    165000  -8022.4977     -8022.4977     -8109.8468     -8109.8468      338.0501       338.0501       24214.793      24214.793     -1096.1387     -1096.1387    
    166000  -8024.0059     -8024.0059     -8111.2778     -8111.2778      337.75133      337.75133      24212.712      24212.712     -1316.9569     -1316.9569    
Loop time of 151.112 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.976 hours/ns, 6.618 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.58     | 150.58     | 150.58     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096537   | 0.096537   | 0.096537   |   0.0 |  0.06
Output  | 0.00016204 | 0.00016204 | 0.00016204 |   0.0 |  0.00
Modify  | 0.37923    | 0.37923    | 0.37923    |   0.0 |  0.25
Other   |            | 0.06076    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205558 ave      205558 max      205558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205558
Ave neighs/atom = 102.779
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.599700208584, Press = -0.0214958903331219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    166000  -8024.0059     -8024.0059     -8111.2778     -8111.2778      337.75133      337.75133      24212.712      24212.712     -1316.9569     -1316.9569    
    167000  -8027.4648     -8027.4648     -8111.09       -8111.09        323.63806      323.63806      24200.633      24200.633     -512.99792     -512.99792    
Loop time of 151.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.047 hours/ns, 6.606 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.83     | 150.83     | 150.83     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096749   | 0.096749   | 0.096749   |   0.0 |  0.06
Output  | 0.00016478 | 0.00016478 | 0.00016478 |   0.0 |  0.00
Modify  | 0.38272    | 0.38272    | 0.38272    |   0.0 |  0.25
Other   |            | 0.06074    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205782 ave      205782 max      205782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205782
Ave neighs/atom = 102.891
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.586334864091, Press = -0.283144331205901
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    167000  -8027.4648     -8027.4648     -8111.09       -8111.09        323.63806      323.63806      24200.633      24200.633     -512.99792     -512.99792    
    168000  -8024.8074     -8024.8074     -8112.2253     -8112.2253      338.31615      338.31615      24182.582      24182.582      920.21078      920.21078    
Loop time of 149.7 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.583 hours/ns, 6.680 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.17     | 149.17     | 149.17     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095997   | 0.095997   | 0.095997   |   0.0 |  0.06
Output  | 0.00016319 | 0.00016319 | 0.00016319 |   0.0 |  0.00
Modify  | 0.37432    | 0.37432    | 0.37432    |   0.0 |  0.25
Other   |            | 0.06017    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205928 ave      205928 max      205928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205928
Ave neighs/atom = 102.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.577629142965, Press = -0.287003627925562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    168000  -8024.8074     -8024.8074     -8112.2253     -8112.2253      338.31615      338.31615      24182.582      24182.582      920.21078      920.21078    
    169000  -8024.9616     -8024.9616     -8111.1146     -8111.1146      333.42135      333.42135      24164.738      24164.738      2497.0016      2497.0016    
Loop time of 151.442 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.067 hours/ns, 6.603 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.9      | 150.9      | 150.9      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096572   | 0.096572   | 0.096572   |   0.0 |  0.06
Output  | 0.00023132 | 0.00023132 | 0.00023132 |   0.0 |  0.00
Modify  | 0.38361    | 0.38361    | 0.38361    |   0.0 |  0.25
Other   |            | 0.06115    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206372 ave      206372 max      206372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206372
Ave neighs/atom = 103.186
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.57877282805, Press = -0.0229457187376301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    169000  -8024.9616     -8024.9616     -8111.1146     -8111.1146      333.42135      333.42135      24164.738      24164.738      2497.0016      2497.0016    
    170000  -8019.5698     -8019.5698     -8105.9537     -8105.9537      334.31449      334.31449      24170.092      24170.092      3195.4595      3195.4595    
Loop time of 153.959 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.561 ns/day, 42.766 hours/ns, 6.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    | 153.41     | 153.41     | 153.41     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097905   | 0.097905   | 0.097905   |   0.0 |  0.06
Output  | 0.00016321 | 0.00016321 | 0.00016321 |   0.0 |  0.00
Modify  | 0.38689    | 0.38689    | 0.38689    |   0.0 |  0.25
Other   |            | 0.06102    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206580 ave      206580 max      206580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206580
Ave neighs/atom = 103.29
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.577850233887, Press = 0.351985487620624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    170000  -8019.5698     -8019.5698     -8105.9537     -8105.9537      334.31449      334.31449      24170.092      24170.092      3195.4595      3195.4595    
    171000  -8024.8495     -8024.8495     -8110.8291     -8110.8291      332.75017      332.75017      24175.717      24175.717      1594.1402      1594.1402    
Loop time of 150.969 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.936 hours/ns, 6.624 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.43     | 150.43     | 150.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096318   | 0.096318   | 0.096318   |   0.0 |  0.06
Output  | 0.00016181 | 0.00016181 | 0.00016181 |   0.0 |  0.00
Modify  | 0.37931    | 0.37931    | 0.37931    |   0.0 |  0.25
Other   |            | 0.06056    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206338 ave      206338 max      206338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206338
Ave neighs/atom = 103.169
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.598391691104, Press = 0.390148136409994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    171000  -8024.8495     -8024.8495     -8110.8291     -8110.8291      332.75017      332.75017      24175.717      24175.717      1594.1402      1594.1402    
    172000  -8021.1256     -8021.1256     -8109.3582     -8109.3582      341.46905      341.46905      24198.361      24198.361      103.63867      103.63867    
Loop time of 155.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.557 ns/day, 43.109 hours/ns, 6.444 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.64     | 154.64     | 154.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098231   | 0.098231   | 0.098231   |   0.0 |  0.06
Output  | 0.0001661  | 0.0001661  | 0.0001661  |   0.0 |  0.00
Modify  | 0.39175    | 0.39175    | 0.39175    |   0.0 |  0.25
Other   |            | 0.06144    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206314 ave      206314 max      206314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206314
Ave neighs/atom = 103.157
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.605632331192, Press = 0.320476672695288
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    172000  -8021.1256     -8021.1256     -8109.3582     -8109.3582      341.46905      341.46905      24198.361      24198.361      103.63867      103.63867    
    173000  -8026.6206     -8026.6206     -8110.9271     -8110.9271      326.27491      326.27491      24207.074      24207.074     -899.47854     -899.47854    
Loop time of 153.347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.596 hours/ns, 6.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    | 152.8      | 152.8      | 152.8      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098384   | 0.098384   | 0.098384   |   0.0 |  0.06
Output  | 0.00016228 | 0.00016228 | 0.00016228 |   0.0 |  0.00
Modify  | 0.38936    | 0.38936    | 0.38936    |   0.0 |  0.25
Other   |            | 0.06133    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205874 ave      205874 max      205874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205874
Ave neighs/atom = 102.937
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.60638212055, Press = 0.209282778020892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    173000  -8026.6206     -8026.6206     -8110.9271     -8110.9271      326.27491      326.27491      24207.074      24207.074     -899.47854     -899.47854    
    174000  -8027.4191     -8027.4191     -8112.5259     -8112.5259      329.37226      329.37226      24203.808      24203.808     -889.93124     -889.93124    
Loop time of 153.275 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.576 hours/ns, 6.524 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.73     | 152.73     | 152.73     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098075   | 0.098075   | 0.098075   |   0.0 |  0.06
Output  | 0.00016258 | 0.00016258 | 0.00016258 |   0.0 |  0.00
Modify  | 0.38806    | 0.38806    | 0.38806    |   0.0 |  0.25
Other   |            | 0.06099    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205714 ave      205714 max      205714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205714
Ave neighs/atom = 102.857
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.598136324129, Press = 0.0352434456237731
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    174000  -8027.4191     -8027.4191     -8112.5259     -8112.5259      329.37226      329.37226      24203.808      24203.808     -889.93124     -889.93124    
    175000  -8027.121      -8027.121      -8112.016      -8112.016       328.55272      328.55272      24203.94       24203.94      -977.07324     -977.07324    
Loop time of 152.176 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.271 hours/ns, 6.571 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.63     | 151.63     | 151.63     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097435   | 0.097435   | 0.097435   |   0.0 |  0.06
Output  | 0.00016218 | 0.00016218 | 0.00016218 |   0.0 |  0.00
Modify  | 0.38502    | 0.38502    | 0.38502    |   0.0 |  0.25
Other   |            | 0.06074    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205830 ave      205830 max      205830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205830
Ave neighs/atom = 102.915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.585244421143, Press = -0.0650847446546832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    175000  -8027.121      -8027.121      -8112.016      -8112.016       328.55272      328.55272      24203.94       24203.94      -977.07324     -977.07324    
    176000  -8024.5849     -8024.5849     -8109.3778     -8109.3778      328.15762      328.15762      24194.601      24194.601      610.96196      610.96196    
Loop time of 152.047 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.235 hours/ns, 6.577 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.5      | 151.5      | 151.5      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098228   | 0.098228   | 0.098228   |   0.0 |  0.06
Output  | 0.00019971 | 0.00019971 | 0.00019971 |   0.0 |  0.00
Modify  | 0.38572    | 0.38572    | 0.38572    |   0.0 |  0.25
Other   |            | 0.06093    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205948 ave      205948 max      205948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205948
Ave neighs/atom = 102.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.586055133805, Press = -0.0569149978816891
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    176000  -8024.5849     -8024.5849     -8109.3778     -8109.3778      328.15762      328.15762      24194.601      24194.601      610.96196      610.96196    
    177000  -8032.8215     -8032.8215     -8116.0631     -8116.0631      322.15365      322.15365      24179.852      24179.852      25.151914      25.151914    
Loop time of 149.963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.657 hours/ns, 6.668 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.43     | 149.43     | 149.43     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096308   | 0.096308   | 0.096308   |   0.0 |  0.06
Output  | 0.00016603 | 0.00016603 | 0.00016603 |   0.0 |  0.00
Modify  | 0.37777    | 0.37777    | 0.37777    |   0.0 |  0.25
Other   |            | 0.06008    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205998 ave      205998 max      205998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205998
Ave neighs/atom = 102.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.568196203429, Press = -0.0575275715974802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    177000  -8032.8215     -8032.8215     -8116.0631     -8116.0631      322.15365      322.15365      24179.852      24179.852      25.151914      25.151914    
    178000  -8024.5128     -8024.5128     -8111.3726     -8111.3726      336.15634      336.15634      24188.734      24188.734      330.19867      330.19867    
Loop time of 149.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.555 hours/ns, 6.685 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.07     | 149.07     | 149.07     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095839   | 0.095839   | 0.095839   |   0.0 |  0.06
Output  | 0.00016447 | 0.00016447 | 0.00016447 |   0.0 |  0.00
Modify  | 0.37489    | 0.37489    | 0.37489    |   0.0 |  0.25
Other   |            | 0.06076    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206702 ave      206702 max      206702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206702
Ave neighs/atom = 103.351
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.549504856842, Press = 0.0588289726726147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    178000  -8024.5128     -8024.5128     -8111.3726     -8111.3726      336.15634      336.15634      24188.734      24188.734      330.19867      330.19867    
    179000  -8027.7652     -8027.7652     -8113.3132     -8113.3132      331.07961      331.07961      24193.847      24193.847     -212.07855     -212.07855    
Loop time of 152.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.322 hours/ns, 6.564 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.81     | 151.81     | 151.81     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097721   | 0.097721   | 0.097721   |   0.0 |  0.06
Output  | 0.00025863 | 0.00025863 | 0.00025863 |   0.0 |  0.00
Modify  | 0.38543    | 0.38543    | 0.38543    |   0.0 |  0.25
Other   |            | 0.06124    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206034 ave      206034 max      206034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206034
Ave neighs/atom = 103.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.546408814733, Press = 0.23514030188607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    179000  -8027.7652     -8027.7652     -8113.3132     -8113.3132      331.07961      331.07961      24193.847      24193.847     -212.07855     -212.07855    
    180000  -8024.0541     -8024.0541     -8109.859      -8109.859       332.07375      332.07375      24228.544      24228.544     -2375.2699     -2375.2699    
Loop time of 149.24 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.456 hours/ns, 6.701 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.71     | 148.71     | 148.71     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095823   | 0.095823   | 0.095823   |   0.0 |  0.06
Output  | 0.00016326 | 0.00016326 | 0.00016326 |   0.0 |  0.00
Modify  | 0.37657    | 0.37657    | 0.37657    |   0.0 |  0.25
Other   |            | 0.05991    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206228 ave      206228 max      206228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206228
Ave neighs/atom = 103.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.535373721483, Press = 0.156471777000275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    180000  -8024.0541     -8024.0541     -8109.859      -8109.859       332.07375      332.07375      24228.544      24228.544     -2375.2699     -2375.2699    
    181000  -8030.0524     -8030.0524     -8112.9406     -8112.9406      320.78611      320.78611      24233.688      24233.688     -3506.7248     -3506.7248    
Loop time of 147.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.587 ns/day, 40.907 hours/ns, 6.791 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 146.74     | 146.74     | 146.74     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095625   | 0.095625   | 0.095625   |   0.0 |  0.06
Output  | 0.00016287 | 0.00016287 | 0.00016287 |   0.0 |  0.00
Modify  | 0.37027    | 0.37027    | 0.37027    |   0.0 |  0.25
Other   |            | 0.06003    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205408 ave      205408 max      205408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205408
Ave neighs/atom = 102.704
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.521252447987, Press = -0.181922829333876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    181000  -8030.0524     -8030.0524     -8112.9406     -8112.9406      320.78611      320.78611      24233.688      24233.688     -3506.7248     -3506.7248    
    182000  -8024.7945     -8024.7945     -8109.9133     -8109.9133      329.41867      329.41867      24223.693      24223.693     -1993.3821     -1993.3821    
Loop time of 147.971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.103 hours/ns, 6.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.44     | 147.44     | 147.44     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094888   | 0.094888   | 0.094888   |   0.0 |  0.06
Output  | 0.00016417 | 0.00016417 | 0.00016417 |   0.0 |  0.00
Modify  | 0.37307    | 0.37307    | 0.37307    |   0.0 |  0.25
Other   |            | 0.05984    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205442 ave      205442 max      205442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205442
Ave neighs/atom = 102.721
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.516762356967, Press = -0.371306012584144
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    182000  -8024.7945     -8024.7945     -8109.9133     -8109.9133      329.41867      329.41867      24223.693      24223.693     -1993.3821     -1993.3821    
    183000  -8025.6733     -8025.6733     -8111.937      -8111.937       333.84925      333.84925      24195.379      24195.379     -4.5597766     -4.5597766    
Loop time of 151.679 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.133 hours/ns, 6.593 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.14     | 151.14     | 151.14     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096439   | 0.096439   | 0.096439   |   0.0 |  0.06
Output  | 0.00022387 | 0.00022387 | 0.00022387 |   0.0 |  0.00
Modify  | 0.38425    | 0.38425    | 0.38425    |   0.0 |  0.25
Other   |            | 0.06074    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205188 ave      205188 max      205188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205188
Ave neighs/atom = 102.594
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.523374518823, Press = -0.123018654061525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    183000  -8025.6733     -8025.6733     -8111.937      -8111.937       333.84925      333.84925      24195.379      24195.379     -4.5597766     -4.5597766    
    184000  -8025.3004     -8025.3004     -8112.7506     -8112.7506      338.44139      338.44139      24188.442      24188.442      374.60871      374.60871    
Loop time of 152.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.449 hours/ns, 6.544 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.27     | 152.27     | 152.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098701   | 0.098701   | 0.098701   |   0.0 |  0.06
Output  | 0.00016187 | 0.00016187 | 0.00016187 |   0.0 |  0.00
Modify  | 0.38415    | 0.38415    | 0.38415    |   0.0 |  0.25
Other   |            | 0.06046    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206218 ave      206218 max      206218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206218
Ave neighs/atom = 103.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.534079957436, Press = -0.0743386682176156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    184000  -8025.3004     -8025.3004     -8112.7506     -8112.7506      338.44139      338.44139      24188.442      24188.442      374.60871      374.60871    
    185000  -8023.9918     -8023.9918     -8110.1482     -8110.1482      333.434        333.434        24172.303      24172.303      2140.5784      2140.5784    
Loop time of 150.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.931 hours/ns, 6.625 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.42     | 150.42     | 150.42     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097224   | 0.097224   | 0.097224   |   0.0 |  0.06
Output  | 0.00020708 | 0.00020708 | 0.00020708 |   0.0 |  0.00
Modify  | 0.37899    | 0.37899    | 0.37899    |   0.0 |  0.25
Other   |            | 0.06081    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206266 ave      206266 max      206266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206266
Ave neighs/atom = 103.133
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.533623709515, Press = 0.0407795960590309
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    185000  -8023.9918     -8023.9918     -8110.1482     -8110.1482      333.434        333.434        24172.303      24172.303      2140.5784      2140.5784    
    186000  -8025.9179     -8025.9179     -8110.9691     -8110.9691      329.1568       329.1568       24162.275      24162.275      2694.2454      2694.2454    
Loop time of 149.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.427 hours/ns, 6.705 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.61     | 148.61     | 148.61     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095465   | 0.095465   | 0.095465   |   0.0 |  0.06
Output  | 0.00016399 | 0.00016399 | 0.00016399 |   0.0 |  0.00
Modify  | 0.37397    | 0.37397    | 0.37397    |   0.0 |  0.25
Other   |            | 0.06011    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206484 ave      206484 max      206484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206484
Ave neighs/atom = 103.242
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.530744166733, Press = 0.326256487445484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    186000  -8025.9179     -8025.9179     -8110.9691     -8110.9691      329.1568       329.1568       24162.275      24162.275      2694.2454      2694.2454    
    187000  -8024.146      -8024.146      -8110.8331     -8110.8331      335.48797      335.48797      24197.726      24197.726      14.746288      14.746288    
Loop time of 150.346 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.763 hours/ns, 6.651 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.81     | 149.81     | 149.81     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096996   | 0.096996   | 0.096996   |   0.0 |  0.06
Output  | 0.00016275 | 0.00016275 | 0.00016275 |   0.0 |  0.00
Modify  | 0.37884    | 0.37884    | 0.37884    |   0.0 |  0.25
Other   |            | 0.05989    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206534 ave      206534 max      206534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206534
Ave neighs/atom = 103.267
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.514374465116, Press = 0.664801426036264
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    187000  -8024.146      -8024.146      -8110.8331     -8110.8331      335.48797      335.48797      24197.726      24197.726      14.746288      14.746288    
    188000  -8022.3841     -8022.3841     -8111.3894     -8111.3894      344.45943      344.45943      24226.758      24226.758     -2450.5021     -2450.5021    
Loop time of 152.328 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.313 hours/ns, 6.565 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.78     | 151.78     | 151.78     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097613   | 0.097613   | 0.097613   |   0.0 |  0.06
Output  | 0.00016289 | 0.00016289 | 0.00016289 |   0.0 |  0.00
Modify  | 0.38597    | 0.38597    | 0.38597    |   0.0 |  0.25
Other   |            | 0.061      |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205808 ave      205808 max      205808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205808
Ave neighs/atom = 102.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.513366524497, Press = 0.264734365446291
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    188000  -8022.3841     -8022.3841     -8111.3894     -8111.3894      344.45943      344.45943      24226.758      24226.758     -2450.5021     -2450.5021    
    189000  -8025.4409     -8025.4409     -8110.3591     -8110.3591      328.64203      328.64203      24204.06       24204.06      -734.90479     -734.90479    
Loop time of 149.425 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.507 hours/ns, 6.692 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.89     | 148.89     | 148.89     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095727   | 0.095727   | 0.095727   |   0.0 |  0.06
Output  | 0.00020579 | 0.00020579 | 0.00020579 |   0.0 |  0.00
Modify  | 0.37858    | 0.37858    | 0.37858    |   0.0 |  0.25
Other   |            | 0.06002    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205262 ave      205262 max      205262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205262
Ave neighs/atom = 102.631
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.511374791058, Press = 0.0917914603306594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    189000  -8025.4409     -8025.4409     -8110.3591     -8110.3591      328.64203      328.64203      24204.06       24204.06      -734.90479     -734.90479    
    190000  -8026.7609     -8026.7609     -8110.9268     -8110.9268      325.73082      325.73082      24200.989      24200.989     -694.60281     -694.60281    
Loop time of 150.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.743 hours/ns, 6.654 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.74     | 149.74     | 149.74     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097124   | 0.097124   | 0.097124   |   0.0 |  0.06
Output  | 0.00020451 | 0.00020451 | 0.00020451 |   0.0 |  0.00
Modify  | 0.37932    | 0.37932    | 0.37932    |   0.0 |  0.25
Other   |            | 0.06057    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205946 ave      205946 max      205946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205946
Ave neighs/atom = 102.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.502011193402, Press = 0.0603378969458544
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    190000  -8026.7609     -8026.7609     -8110.9268     -8110.9268      325.73082      325.73082      24200.989      24200.989     -694.60281     -694.60281    
    191000  -8026.8424     -8026.8424     -8112.4094     -8112.4094      331.15301      331.15301      24211.158      24211.158     -1406.3837     -1406.3837    
Loop time of 148.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.319 hours/ns, 6.723 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.22     | 148.22     | 148.22     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095003   | 0.095003   | 0.095003   |   0.0 |  0.06
Output  | 0.00016483 | 0.00016483 | 0.00016483 |   0.0 |  0.00
Modify  | 0.37172    | 0.37172    | 0.37172    |   0.0 |  0.25
Other   |            | 0.05998    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206040 ave      206040 max      206040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206040
Ave neighs/atom = 103.02
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.491368112692, Press = -0.00281813306761862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    191000  -8026.8424     -8026.8424     -8112.4094     -8112.4094      331.15301      331.15301      24211.158      24211.158     -1406.3837     -1406.3837    
    192000  -8025.5417     -8025.5417     -8109.3215     -8109.3215      324.23656      324.23656      24226.664      24226.664     -2161.2966     -2161.2966    
Loop time of 150.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.818 hours/ns, 6.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    | 150.01     | 150.01     | 150.01     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096921   | 0.096921   | 0.096921   |   0.0 |  0.06
Output  | 0.00016334 | 0.00016334 | 0.00016334 |   0.0 |  0.00
Modify  | 0.37972    | 0.37972    | 0.37972    |   0.0 |  0.25
Other   |            | 0.06071    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206062 ave      206062 max      206062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206062
Ave neighs/atom = 103.031
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.49269510229, Press = -0.306201144525446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    192000  -8025.5417     -8025.5417     -8109.3215     -8109.3215      324.23656      324.23656      24226.664      24226.664     -2161.2966     -2161.2966    
    193000  -8022.9825     -8022.9825     -8109.5126     -8109.5126      334.88023      334.88023      24203.718      24203.718     -205.55267     -205.55267    
Loop time of 149.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.573 hours/ns, 6.682 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.13     | 149.13     | 149.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096054   | 0.096054   | 0.096054   |   0.0 |  0.06
Output  | 0.00051402 | 0.00051402 | 0.00051402 |   0.0 |  0.00
Modify  | 0.37762    | 0.37762    | 0.37762    |   0.0 |  0.25
Other   |            | 0.06054    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205284 ave      205284 max      205284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205284
Ave neighs/atom = 102.642
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.484260940681, Press = -0.510110084014765
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    193000  -8022.9825     -8022.9825     -8109.5126     -8109.5126      334.88023      334.88023      24203.718      24203.718     -205.55267     -205.55267    
    194000  -8028.9474     -8028.9474     -8111.1401     -8111.1401      318.09412      318.09412      24169.699      24169.699      1814.2793      1814.2793    
Loop time of 151.019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.950 hours/ns, 6.622 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.48     | 150.48     | 150.48     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096462   | 0.096462   | 0.096462   |   0.0 |  0.06
Output  | 0.00016478 | 0.00016478 | 0.00016478 |   0.0 |  0.00
Modify  | 0.38134    | 0.38134    | 0.38134    |   0.0 |  0.25
Other   |            | 0.06074    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205864 ave      205864 max      205864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205864
Ave neighs/atom = 102.932
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.468360922021, Press = -0.269067885709536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    194000  -8028.9474     -8028.9474     -8111.1401     -8111.1401      318.09412      318.09412      24169.699      24169.699      1814.2793      1814.2793    
    195000  -8023.6686     -8023.6686     -8109.4071     -8109.4071      331.81693      331.81693      24169.036      24169.036      2439.241       2439.241     
Loop time of 149.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.398 hours/ns, 6.710 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.5      | 148.5      | 148.5      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095525   | 0.095525   | 0.095525   |   0.0 |  0.06
Output  | 0.00016582 | 0.00016582 | 0.00016582 |   0.0 |  0.00
Modify  | 0.37269    | 0.37269    | 0.37269    |   0.0 |  0.25
Other   |            | 0.06       |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206638 ave      206638 max      206638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206638
Ave neighs/atom = 103.319
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.454319714712, Press = -0.0503091067508147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    195000  -8023.6686     -8023.6686     -8109.4071     -8109.4071      331.81693      331.81693      24169.036      24169.036      2439.241       2439.241     
    196000  -8026.3725     -8026.3725     -8112.1573     -8112.1573      331.99592      331.99592      24176.439      24176.439      1239.0301      1239.0301    
Loop time of 150.422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.784 hours/ns, 6.648 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.89     | 149.89     | 149.89     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096114   | 0.096114   | 0.096114   |   0.0 |  0.06
Output  | 0.00020389 | 0.00020389 | 0.00020389 |   0.0 |  0.00
Modify  | 0.38033    | 0.38033    | 0.38033    |   0.0 |  0.25
Other   |            | 0.06047    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206374 ave      206374 max      206374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206374
Ave neighs/atom = 103.187
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.440754490026, Press = 0.168934947023832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    196000  -8026.3725     -8026.3725     -8112.1573     -8112.1573      331.99592      331.99592      24176.439      24176.439      1239.0301      1239.0301    
    197000  -8026.0767     -8026.0767     -8110.8053     -8110.8053      327.90856      327.90856      24188.555      24188.555      608.11982      608.11982    
Loop time of 149.865 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.629 hours/ns, 6.673 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.33     | 149.33     | 149.33     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095941   | 0.095941   | 0.095941   |   0.0 |  0.06
Output  | 0.00016507 | 0.00016507 | 0.00016507 |   0.0 |  0.00
Modify  | 0.37732    | 0.37732    | 0.37732    |   0.0 |  0.25
Other   |            | 0.06018    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206516 ave      206516 max      206516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206516
Ave neighs/atom = 103.258
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.443374672518, Press = 0.147661101916311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    197000  -8026.0767     -8026.0767     -8110.8053     -8110.8053      327.90856      327.90856      24188.555      24188.555      608.11982      608.11982    
    198000  -8023.8122     -8023.8122     -8110.4915     -8110.4915      335.45801      335.45801      24201.25       24201.25       79.312145      79.312145    
Loop time of 148.56 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.267 hours/ns, 6.731 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.03     | 148.03     | 148.03     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096333   | 0.096333   | 0.096333   |   0.0 |  0.06
Output  | 0.00020589 | 0.00020589 | 0.00020589 |   0.0 |  0.00
Modify  | 0.37357    | 0.37357    | 0.37357    |   0.0 |  0.25
Other   |            | 0.05957    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206236 ave      206236 max      206236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206236
Ave neighs/atom = 103.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.451657439006, Press = 0.14579429573021
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    198000  -8023.8122     -8023.8122     -8110.4915     -8110.4915      335.45801      335.45801      24201.25       24201.25       79.312145      79.312145    
    199000  -8025.014      -8025.014      -8110.4457     -8110.4457      330.62983      330.62983      24210.941      24210.941     -1226.7256     -1226.7256    
Loop time of 150.509 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.808 hours/ns, 6.644 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.97     | 149.97     | 149.97     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097106   | 0.097106   | 0.097106   |   0.0 |  0.06
Output  | 0.00016278 | 0.00016278 | 0.00016278 |   0.0 |  0.00
Modify  | 0.3806     | 0.3806     | 0.3806     |   0.0 |  0.25
Other   |            | 0.06042    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206038 ave      206038 max      206038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206038
Ave neighs/atom = 103.019
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.454766295162, Press = 0.0216057414848065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    199000  -8025.014      -8025.014      -8110.4457     -8110.4457      330.62983      330.62983      24210.941      24210.941     -1226.7256     -1226.7256    
    200000  -8027.5886     -8027.5886     -8112.1165     -8112.1165      327.13179      327.13179      24230.736      24230.736     -3187.0775     -3187.0775    
Loop time of 151.585 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.107 hours/ns, 6.597 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.04     | 151.04     | 151.04     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098308   | 0.098308   | 0.098308   |   0.0 |  0.06
Output  | 0.00016086 | 0.00016086 | 0.00016086 |   0.0 |  0.00
Modify  | 0.38428    | 0.38428    | 0.38428    |   0.0 |  0.25
Other   |            | 0.06132    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205544 ave      205544 max      205544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205544
Ave neighs/atom = 102.772
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.437068114505, Press = -0.253576393899919
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    200000  -8027.5886     -8027.5886     -8112.1165     -8112.1165      327.13179      327.13179      24230.736      24230.736     -3187.0775     -3187.0775    
    201000  -8024.1473     -8024.1473     -8110.8049     -8110.8049      335.37392      335.37392      24217.564      24217.564     -1592.0849     -1592.0849    
Loop time of 145.971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.592 ns/day, 40.547 hours/ns, 6.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 145.45     | 145.45     | 145.45     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094225   | 0.094225   | 0.094225   |   0.0 |  0.06
Output  | 0.00016219 | 0.00016219 | 0.00016219 |   0.0 |  0.00
Modify  | 0.36538    | 0.36538    | 0.36538    |   0.0 |  0.25
Other   |            | 0.05952    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205242 ave      205242 max      205242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205242
Ave neighs/atom = 102.621
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.431556722425, Press = -0.643599118547286
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    201000  -8024.1473     -8024.1473     -8110.8049     -8110.8049      335.37392      335.37392      24217.564      24217.564     -1592.0849     -1592.0849    
    202000  -8027.8022     -8027.8022     -8113.8585     -8113.8585      333.0467       333.0467       24179.28       24179.28       779.93804      779.93804    
Loop time of 150.536 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.815 hours/ns, 6.643 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150        | 150        | 150        |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097432   | 0.097432   | 0.097432   |   0.0 |  0.06
Output  | 0.00016857 | 0.00016857 | 0.00016857 |   0.0 |  0.00
Modify  | 0.38022    | 0.38022    | 0.38022    |   0.0 |  0.25
Other   |            | 0.05997    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205688 ave      205688 max      205688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205688
Ave neighs/atom = 102.844
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.418268275545, Press = -0.241519418569353
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    202000  -8027.8022     -8027.8022     -8113.8585     -8113.8585      333.0467       333.0467       24179.28       24179.28       779.93804      779.93804    
    203000  -8022.5505     -8022.5505     -8109.8782     -8109.8782      337.96726      337.96726      24181.294      24181.294      1500.5839      1500.5839    
Loop time of 150.187 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.719 hours/ns, 6.658 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.65     | 149.65     | 149.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096272   | 0.096272   | 0.096272   |   0.0 |  0.06
Output  | 0.00016138 | 0.00016138 | 0.00016138 |   0.0 |  0.00
Modify  | 0.37809    | 0.37809    | 0.37809    |   0.0 |  0.25
Other   |            | 0.06084    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206320 ave      206320 max      206320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206320
Ave neighs/atom = 103.16
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.412551896269, Press = -0.0440399292730283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    203000  -8022.5505     -8022.5505     -8109.8782     -8109.8782      337.96726      337.96726      24181.294      24181.294      1500.5839      1500.5839    
    204000  -8024.3567     -8024.3567     -8110.4598     -8110.4598      333.22787      333.22787      24180.945      24180.945      1395.9167      1395.9167    
Loop time of 151.774 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.159 hours/ns, 6.589 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.23     | 151.23     | 151.23     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097      | 0.097      | 0.097      |   0.0 |  0.06
Output  | 0.00016433 | 0.00016433 | 0.00016433 |   0.0 |  0.00
Modify  | 0.38364    | 0.38364    | 0.38364    |   0.0 |  0.25
Other   |            | 0.06127    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205966 ave      205966 max      205966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205966
Ave neighs/atom = 102.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.410871914158, Press = 0.101891588052504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    204000  -8024.3567     -8024.3567     -8110.4598     -8110.4598      333.22787      333.22787      24180.945      24180.945      1395.9167      1395.9167    
    205000  -8019.2294     -8019.2294     -8109.7351     -8109.7351      350.26636      350.26636      24199.731      24199.731      64.673184      64.673184    
Loop time of 152.054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.237 hours/ns, 6.577 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.51     | 151.51     | 151.51     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097782   | 0.097782   | 0.097782   |   0.0 |  0.06
Output  | 0.00016168 | 0.00016168 | 0.00016168 |   0.0 |  0.00
Modify  | 0.38512    | 0.38512    | 0.38512    |   0.0 |  0.25
Other   |            | 0.06044    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206110 ave      206110 max      206110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206110
Ave neighs/atom = 103.055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.409971076013, Press = 0.329295994033897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    205000  -8019.2294     -8019.2294     -8109.7351     -8109.7351      350.26636      350.26636      24199.731      24199.731      64.673184      64.673184    
    206000  -8026.2044     -8026.2044     -8112.1169     -8112.1169      332.49009      332.49009      24218.57       24218.57      -2092.7428     -2092.7428    
Loop time of 151.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.157 hours/ns, 6.589 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.22     | 151.22     | 151.22     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097046   | 0.097046   | 0.097046   |   0.0 |  0.06
Output  | 0.00016953 | 0.00016953 | 0.00016953 |   0.0 |  0.00
Modify  | 0.3834     | 0.3834     | 0.3834     |   0.0 |  0.25
Other   |            | 0.06116    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205700 ave      205700 max      205700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205700
Ave neighs/atom = 102.85
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.422145750658, Press = 0.467425727280999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    206000  -8026.2044     -8026.2044     -8112.1169     -8112.1169      332.49009      332.49009      24218.57       24218.57      -2092.7428     -2092.7428    
    207000  -8020.5825     -8020.5825     -8108.1503     -8108.1503      338.89638      338.89638      24242.915      24242.915     -2863.0322     -2863.0322    
Loop time of 151.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.955 hours/ns, 6.621 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.5      | 150.5      | 150.5      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096725   | 0.096725   | 0.096725   |   0.0 |  0.06
Output  | 0.00016486 | 0.00016486 | 0.00016486 |   0.0 |  0.00
Modify  | 0.38177    | 0.38177    | 0.38177    |   0.0 |  0.25
Other   |            | 0.06089    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205472 ave      205472 max      205472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205472
Ave neighs/atom = 102.736
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.4285467754, Press = 0.190253532868803
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    207000  -8020.5825     -8020.5825     -8108.1503     -8108.1503      338.89638      338.89638      24242.915      24242.915     -2863.0322     -2863.0322    
    208000  -8023.5079     -8023.5079     -8108.4939     -8108.4939      328.90463      328.90463      24235.507      24235.507     -2560.4509     -2560.4509    
Loop time of 152.542 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.373 hours/ns, 6.556 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152        | 152        | 152        |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097601   | 0.097601   | 0.097601   |   0.0 |  0.06
Output  | 0.00016021 | 0.00016021 | 0.00016021 |   0.0 |  0.00
Modify  | 0.38572    | 0.38572    | 0.38572    |   0.0 |  0.25
Other   |            | 0.06141    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204868 ave      204868 max      204868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204868
Ave neighs/atom = 102.434
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.437670027868, Press = -0.0939124725359805
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    208000  -8023.5079     -8023.5079     -8108.4939     -8108.4939      328.90463      328.90463      24235.507      24235.507     -2560.4509     -2560.4509    
    209000  -8022.5898     -8022.5898     -8110.0322     -8110.0322      338.41104      338.41104      24221.771      24221.771     -1814.4875     -1814.4875    
Loop time of 151.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.003 hours/ns, 6.613 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.67     | 150.67     | 150.67     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097288   | 0.097288   | 0.097288   |   0.0 |  0.06
Output  | 0.00016417 | 0.00016417 | 0.00016417 |   0.0 |  0.00
Modify  | 0.3837     | 0.3837     | 0.3837     |   0.0 |  0.25
Other   |            | 0.06109    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204966 ave      204966 max      204966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204966
Ave neighs/atom = 102.483
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.429972448723, Press = -0.233466078316029
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    209000  -8022.5898     -8022.5898     -8110.0322     -8110.0322      338.41104      338.41104      24221.771      24221.771     -1814.4875     -1814.4875    
    210000  -8027.8473     -8027.8473     -8112.8414     -8112.8414      328.936        328.936        24196.268      24196.268     -509.1365      -509.1365     
Loop time of 148.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.249 hours/ns, 6.734 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.96     | 147.96     | 147.96     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09587    | 0.09587    | 0.09587    |   0.0 |  0.06
Output  | 0.00016529 | 0.00016529 | 0.00016529 |   0.0 |  0.00
Modify  | 0.37506    | 0.37506    | 0.37506    |   0.0 |  0.25
Other   |            | 0.06075    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205462 ave      205462 max      205462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205462
Ave neighs/atom = 102.731
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.4213167173, Press = -0.323869696378745
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    210000  -8027.8473     -8027.8473     -8112.8414     -8112.8414      328.936        328.936        24196.268      24196.268     -509.1365      -509.1365     
    211000  -8024.5557     -8024.5557     -8110.7959     -8110.7959      333.75863      333.75863      24175.014      24175.014      1689.3533      1689.3533    
Loop time of 149.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.492 hours/ns, 6.695 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.84     | 148.84     | 148.84     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095827   | 0.095827   | 0.095827   |   0.0 |  0.06
Output  | 0.00016361 | 0.00016361 | 0.00016361 |   0.0 |  0.00
Modify  | 0.37421    | 0.37421    | 0.37421    |   0.0 |  0.25
Other   |            | 0.05971    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206142 ave      206142 max      206142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206142
Ave neighs/atom = 103.071
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.420004762751, Press = -0.335240077939835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    211000  -8024.5557     -8024.5557     -8110.7959     -8110.7959      333.75863      333.75863      24175.014      24175.014      1689.3533      1689.3533    
    212000  -8023.6262     -8023.6262     -8109.6859     -8109.6859      333.05987      333.05987      24164.243      24164.243      2750.4741      2750.4741    
Loop time of 149.381 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.495 hours/ns, 6.694 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.85     | 148.85     | 148.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096676   | 0.096676   | 0.096676   |   0.0 |  0.06
Output  | 0.00016412 | 0.00016412 | 0.00016412 |   0.0 |  0.00
Modify  | 0.37649    | 0.37649    | 0.37649    |   0.0 |  0.25
Other   |            | 0.06009    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206342 ave      206342 max      206342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206342
Ave neighs/atom = 103.171
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.423746794896, Press = -0.159187723753093
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    212000  -8023.6262     -8023.6262     -8109.6859     -8109.6859      333.05987      333.05987      24164.243      24164.243      2750.4741      2750.4741    
    213000  -8025.801      -8025.801      -8112.2113     -8112.2113      334.4169       334.4169       24175.497      24175.497      1306.581       1306.581     
Loop time of 149.871 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.631 hours/ns, 6.672 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.34     | 149.34     | 149.34     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096408   | 0.096408   | 0.096408   |   0.0 |  0.06
Output  | 0.00030087 | 0.00030087 | 0.00030087 |   0.0 |  0.00
Modify  | 0.37828    | 0.37828    | 0.37828    |   0.0 |  0.25
Other   |            | 0.06035    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206542 ave      206542 max      206542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206542
Ave neighs/atom = 103.271
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.429245982845, Press = 0.0745624042483366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    213000  -8025.801      -8025.801      -8112.2113     -8112.2113      334.4169       334.4169       24175.497      24175.497      1306.581       1306.581     
    214000  -8022.4928     -8022.4928     -8112.3053     -8112.3053      347.58368      347.58368      24195.521      24195.521     -82.711556     -82.711556    
Loop time of 151.681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.134 hours/ns, 6.593 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.14     | 151.14     | 151.14     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0973     | 0.0973     | 0.0973     |   0.0 |  0.06
Output  | 0.00016273 | 0.00016273 | 0.00016273 |   0.0 |  0.00
Modify  | 0.38372    | 0.38372    | 0.38372    |   0.0 |  0.25
Other   |            | 0.06078    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206466 ave      206466 max      206466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206466
Ave neighs/atom = 103.233
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.436865138706, Press = 0.0683114253287878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    214000  -8022.4928     -8022.4928     -8112.3053     -8112.3053      347.58368      347.58368      24195.521      24195.521     -82.711556     -82.711556    
    215000  -8029.2301     -8029.2301     -8114.7736     -8114.7736      331.06229      331.06229      24186.232      24186.232     -282.16606     -282.16606    
Loop time of 149.384 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.496 hours/ns, 6.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    | 148.85     | 148.85     | 148.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096938   | 0.096938   | 0.096938   |   0.0 |  0.06
Output  | 0.00016182 | 0.00016182 | 0.00016182 |   0.0 |  0.00
Modify  | 0.37787    | 0.37787    | 0.37787    |   0.0 |  0.25
Other   |            | 0.05995    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206074 ave      206074 max      206074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206074
Ave neighs/atom = 103.037
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.42362580897, Press = 0.154695946245464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    215000  -8029.2301     -8029.2301     -8114.7736     -8114.7736      331.06229      331.06229      24186.232      24186.232     -282.16606     -282.16606    
    216000  -8025.1195     -8025.1195     -8110.1288     -8110.1288      328.99469      328.99469      24210.491      24210.491     -987.28861     -987.28861    
Loop time of 151.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.121 hours/ns, 6.595 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.1      | 151.1      | 151.1      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096625   | 0.096625   | 0.096625   |   0.0 |  0.06
Output  | 0.00016298 | 0.00016298 | 0.00016298 |   0.0 |  0.00
Modify  | 0.38069    | 0.38069    | 0.38069    |   0.0 |  0.25
Other   |            | 0.06053    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206230 ave      206230 max      206230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206230
Ave neighs/atom = 103.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.418518770798, Press = 0.245405891312911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    216000  -8025.1195     -8025.1195     -8110.1288     -8110.1288      328.99469      328.99469      24210.491      24210.491     -987.28861     -987.28861    
    217000  -8024.4326     -8024.4326     -8111.7974     -8111.7974      338.11103      338.11103      24243.772      24243.772     -3870.3952     -3870.3952    
Loop time of 149.495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.526 hours/ns, 6.689 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.96     | 148.96     | 148.96     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096805   | 0.096805   | 0.096805   |   0.0 |  0.06
Output  | 0.00016523 | 0.00016523 | 0.00016523 |   0.0 |  0.00
Modify  | 0.37454    | 0.37454    | 0.37454    |   0.0 |  0.25
Other   |            | 0.06022    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205606 ave      205606 max      205606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205606
Ave neighs/atom = 102.803
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.409278060692, Press = 0.0953699578487311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    217000  -8024.4326     -8024.4326     -8111.7974     -8111.7974      338.11103      338.11103      24243.772      24243.772     -3870.3952     -3870.3952    
    218000  -8027.1498     -8027.1498     -8112.3551     -8112.3551      329.75331      329.75331      24232.42       24232.42      -3297.0553     -3297.0553    
Loop time of 152.768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.436 hours/ns, 6.546 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.22     | 152.22     | 152.22     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097943   | 0.097943   | 0.097943   |   0.0 |  0.06
Output  | 0.00016134 | 0.00016134 | 0.00016134 |   0.0 |  0.00
Modify  | 0.38715    | 0.38715    | 0.38715    |   0.0 |  0.25
Other   |            | 0.06117    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204950 ave      204950 max      204950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204950
Ave neighs/atom = 102.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.406207490955, Press = -0.179579398996682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    218000  -8027.1498     -8027.1498     -8112.3551     -8112.3551      329.75331      329.75331      24232.42       24232.42      -3297.0553     -3297.0553    
    219000  -8023.6487     -8023.6487     -8110.7297     -8110.7297      337.01222      337.01222      24209.606      24209.606     -976.57763     -976.57763    
Loop time of 151.683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.134 hours/ns, 6.593 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.14     | 151.14     | 151.14     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096857   | 0.096857   | 0.096857   |   0.0 |  0.06
Output  | 0.00016329 | 0.00016329 | 0.00016329 |   0.0 |  0.00
Modify  | 0.38433    | 0.38433    | 0.38433    |   0.0 |  0.25
Other   |            | 0.06129    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205306 ave      205306 max      205306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205306
Ave neighs/atom = 102.653
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.388659046017, Press = -0.136941780698493
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    219000  -8023.6487     -8023.6487     -8110.7297     -8110.7297      337.01222      337.01222      24209.606      24209.606     -976.57763     -976.57763    
    220000  -8027.4206     -8027.4206     -8112.9433     -8112.9433      330.98166      330.98166      24190.248      24190.248     -5.4508879     -5.4508879    
Loop time of 151.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.125 hours/ns, 6.594 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.11     | 151.11     | 151.11     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096726   | 0.096726   | 0.096726   |   0.0 |  0.06
Output  | 0.00016122 | 0.00016122 | 0.00016122 |   0.0 |  0.00
Modify  | 0.38363    | 0.38363    | 0.38363    |   0.0 |  0.25
Other   |            | 0.06091    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205642 ave      205642 max      205642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205642
Ave neighs/atom = 102.821
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.383081607438, Press = -0.0732670394913132
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    220000  -8027.4206     -8027.4206     -8112.9433     -8112.9433      330.98166      330.98166      24190.248      24190.248     -5.4508879     -5.4508879    
    221000  -8026.0552     -8026.0552     -8109.4881     -8109.4881      322.89396      322.89396      24186.562      24186.562      927.6025       927.6025     
Loop time of 150.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.728 hours/ns, 6.657 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.68     | 149.68     | 149.68     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096621   | 0.096621   | 0.096621   |   0.0 |  0.06
Output  | 0.0001626  | 0.0001626  | 0.0001626  |   0.0 |  0.00
Modify  | 0.37943    | 0.37943    | 0.37943    |   0.0 |  0.25
Other   |            | 0.06062    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206288 ave      206288 max      206288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206288
Ave neighs/atom = 103.144
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.373743398043, Press = -0.0772665573507122
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    221000  -8026.0552     -8026.0552     -8109.4881     -8109.4881      322.89396      322.89396      24186.562      24186.562      927.6025       927.6025     
    222000  -8026.4146     -8026.4146     -8112.8905     -8112.8905      334.67036      334.67036      24186.654      24186.654      337.69013      337.69013    
Loop time of 150.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.884 hours/ns, 6.632 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.24     | 150.24     | 150.24     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097418   | 0.097418   | 0.097418   |   0.0 |  0.06
Output  | 0.00016385 | 0.00016385 | 0.00016385 |   0.0 |  0.00
Modify  | 0.37987    | 0.37987    | 0.37987    |   0.0 |  0.25
Other   |            | 0.06131    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206014 ave      206014 max      206014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206014
Ave neighs/atom = 103.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.377937583884, Press = -0.00253929462989197
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    222000  -8026.4146     -8026.4146     -8112.8905     -8112.8905      334.67036      334.67036      24186.654      24186.654      337.69013      337.69013    
    223000  -8020.5748     -8020.5748     -8106.4715     -8106.4715      332.42878      332.42878      24198.393      24198.393      733.35016      733.35016    
Loop time of 148.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.363 hours/ns, 6.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    | 148.38     | 148.38     | 148.38     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095857   | 0.095857   | 0.095857   |   0.0 |  0.06
Output  | 0.00016478 | 0.00016478 | 0.00016478 |   0.0 |  0.00
Modify  | 0.37188    | 0.37188    | 0.37188    |   0.0 |  0.25
Other   |            | 0.06016    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206212 ave      206212 max      206212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206212
Ave neighs/atom = 103.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.38426475573, Press = 0.0194284675716017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    223000  -8020.5748     -8020.5748     -8106.4715     -8106.4715      332.42878      332.42878      24198.393      24198.393      733.35016      733.35016    
    224000  -8025.3925     -8025.3925     -8111.5691     -8111.5691      333.51205      333.51205      24183.491      24183.491      833.54129      833.54129    
Loop time of 148.94 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.372 hours/ns, 6.714 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.41     | 148.41     | 148.41     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09507    | 0.09507    | 0.09507    |   0.0 |  0.06
Output  | 0.00046422 | 0.00046422 | 0.00046422 |   0.0 |  0.00
Modify  | 0.37486    | 0.37486    | 0.37486    |   0.0 |  0.25
Other   |            | 0.05982    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205634 ave      205634 max      205634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205634
Ave neighs/atom = 102.817
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.392746579048, Press = 0.105533986723245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    224000  -8025.3925     -8025.3925     -8111.5691     -8111.5691      333.51205      333.51205      24183.491      24183.491      833.54129      833.54129    
    225000  -8023.1497     -8023.1497     -8109.1953     -8109.1953      333.00529      333.00529      24200.732      24200.732      32.564771      32.564771    
Loop time of 149.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.592 hours/ns, 6.679 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.2      | 149.2      | 149.2      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096079   | 0.096079   | 0.096079   |   0.0 |  0.06
Output  | 0.00016221 | 0.00016221 | 0.00016221 |   0.0 |  0.00
Modify  | 0.3758     | 0.3758     | 0.3758     |   0.0 |  0.25
Other   |            | 0.06002    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206212 ave      206212 max      206212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206212
Ave neighs/atom = 103.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.403129205429, Press = 0.272926010647847
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    225000  -8023.1497     -8023.1497     -8109.1953     -8109.1953      333.00529      333.00529      24200.732      24200.732      32.564771      32.564771    
    226000  -8028.2464     -8028.2464     -8111.0527     -8111.0527      320.46883      320.46883      24218.456      24218.456     -1721.4865     -1721.4865    
Loop time of 147.861 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.072 hours/ns, 6.763 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.34     | 147.34     | 147.34     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094463   | 0.094463   | 0.094463   |   0.0 |  0.06
Output  | 0.00016754 | 0.00016754 | 0.00016754 |   0.0 |  0.00
Modify  | 0.36999    | 0.36999    | 0.36999    |   0.0 |  0.25
Other   |            | 0.05986    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205800 ave      205800 max      205800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205800
Ave neighs/atom = 102.9
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.397208138495, Press = 0.200674897802662
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    226000  -8028.2464     -8028.2464     -8111.0527     -8111.0527      320.46883      320.46883      24218.456      24218.456     -1721.4865     -1721.4865    
    227000  -8022.9103     -8022.9103     -8110.699      -8110.699       339.75145      339.75145      24243.941      24243.941     -3722.8576     -3722.8576    
Loop time of 148.872 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.353 hours/ns, 6.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    | 148.34     | 148.34     | 148.34     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096029   | 0.096029   | 0.096029   |   0.0 |  0.06
Output  | 0.00016376 | 0.00016376 | 0.00016376 |   0.0 |  0.00
Modify  | 0.3745     | 0.3745     | 0.3745     |   0.0 |  0.25
Other   |            | 0.0598     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205686 ave      205686 max      205686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205686
Ave neighs/atom = 102.843
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.393136810361, Press = -0.0464158545817655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    227000  -8022.9103     -8022.9103     -8110.699      -8110.699       339.75145      339.75145      24243.941      24243.941     -3722.8576     -3722.8576    
    228000  -8024.976      -8024.976      -8110.8784     -8110.8784      332.45108      332.45108      24227.395      24227.395     -2521.1325     -2521.1325    
Loop time of 149.278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.466 hours/ns, 6.699 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.74     | 148.74     | 148.74     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096152   | 0.096152   | 0.096152   |   0.0 |  0.06
Output  | 0.00025564 | 0.00025564 | 0.00025564 |   0.0 |  0.00
Modify  | 0.37704    | 0.37704    | 0.37704    |   0.0 |  0.25
Other   |            | 0.06068    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204928 ave      204928 max      204928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204928
Ave neighs/atom = 102.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.39483263635, Press = -0.282799281494412
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    228000  -8024.976      -8024.976      -8110.8784     -8110.8784      332.45108      332.45108      24227.395      24227.395     -2521.1325     -2521.1325    
    229000  -8024.5347     -8024.5347     -8112.8957     -8112.8957      341.96624      341.96624      24203.176      24203.176     -910.4612      -910.4612     
Loop time of 148.66 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.294 hours/ns, 6.727 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.13     | 148.13     | 148.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096315   | 0.096315   | 0.096315   |   0.0 |  0.06
Output  | 0.0002053  | 0.0002053  | 0.0002053  |   0.0 |  0.00
Modify  | 0.37488    | 0.37488    | 0.37488    |   0.0 |  0.25
Other   |            | 0.05998    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205312 ave      205312 max      205312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205312
Ave neighs/atom = 102.656
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.389372682233, Press = -0.281966341227055
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    229000  -8024.5347     -8024.5347     -8112.8957     -8112.8957      341.96624      341.96624      24203.176      24203.176     -910.4612      -910.4612     
    230000  -8027.1928     -8027.1928     -8111.0834     -8111.0834      324.66527      324.66527      24176.599      24176.599      1512.1478      1512.1478    
Loop time of 152.193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.276 hours/ns, 6.571 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.65     | 151.65     | 151.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099037   | 0.099037   | 0.099037   |   0.0 |  0.07
Output  | 0.00020567 | 0.00020567 | 0.00020567 |   0.0 |  0.00
Modify  | 0.38563    | 0.38563    | 0.38563    |   0.0 |  0.25
Other   |            | 0.06112    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205874 ave      205874 max      205874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205874
Ave neighs/atom = 102.937
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.389112649451, Press = -0.230168065875718
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    230000  -8027.1928     -8027.1928     -8111.0834     -8111.0834      324.66527      324.66527      24176.599      24176.599      1512.1478      1512.1478    
    231000  -8023.6889     -8023.6889     -8113.5966     -8113.5966      347.95217      347.95217      24157.307      24157.307      2717.3116      2717.3116    
Loop time of 150.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.691 hours/ns, 6.663 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.55     | 149.55     | 149.55     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096933   | 0.096933   | 0.096933   |   0.0 |  0.06
Output  | 0.00016276 | 0.00016276 | 0.00016276 |   0.0 |  0.00
Modify  | 0.37817    | 0.37817    | 0.37817    |   0.0 |  0.25
Other   |            | 0.0595     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206512 ave      206512 max      206512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206512
Ave neighs/atom = 103.256
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.382084862045, Press = -0.134474565814733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    231000  -8023.6889     -8023.6889     -8113.5966     -8113.5966      347.95217      347.95217      24157.307      24157.307      2717.3116      2717.3116    
    232000  -8026.9974     -8026.9974     -8112.7038     -8112.7038      331.69273      331.69273      24125.598      24125.598      5131.4223      5131.4223    
Loop time of 151.862 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.184 hours/ns, 6.585 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.32     | 151.32     | 151.32     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097496   | 0.097496   | 0.097496   |   0.0 |  0.06
Output  | 0.00016484 | 0.00016484 | 0.00016484 |   0.0 |  0.00
Modify  | 0.38126    | 0.38126    | 0.38126    |   0.0 |  0.25
Other   |            | 0.06061    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206756 ave      206756 max      206756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206756
Ave neighs/atom = 103.378
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.37275889252, Press = 0.284093739463062
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    232000  -8026.9974     -8026.9974     -8112.7038     -8112.7038      331.69273      331.69273      24125.598      24125.598      5131.4223      5131.4223    
    233000  -8021.9276     -8021.9276     -8108.4713     -8108.4713      334.93283      334.93283      24186.508      24186.508      1290.2722      1290.2722    
Loop time of 152.887 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.469 hours/ns, 6.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    | 152.34     | 152.34     | 152.34     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097555   | 0.097555   | 0.097555   |   0.0 |  0.06
Output  | 0.00016189 | 0.00016189 | 0.00016189 |   0.0 |  0.00
Modify  | 0.38846    | 0.38846    | 0.38846    |   0.0 |  0.25
Other   |            | 0.06064    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       207454 ave      207454 max      207454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 207454
Ave neighs/atom = 103.727
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.371712355278, Press = 0.339175385014605
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    233000  -8021.9276     -8021.9276     -8108.4713     -8108.4713      334.93283      334.93283      24186.508      24186.508      1290.2722      1290.2722    
    234000  -8027.264      -8027.264      -8109.5103     -8109.5103      318.30143      318.30143      24202.004      24202.004     -496.10519     -496.10519    
Loop time of 151.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.953 hours/ns, 6.621 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.49     | 150.49     | 150.49     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097436   | 0.097436   | 0.097436   |   0.0 |  0.06
Output  | 0.00016352 | 0.00016352 | 0.00016352 |   0.0 |  0.00
Modify  | 0.38483    | 0.38483    | 0.38483    |   0.0 |  0.25
Other   |            | 0.06048    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205924 ave      205924 max      205924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205924
Ave neighs/atom = 102.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.381204711892, Press = 0.207183784434783
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    234000  -8027.264      -8027.264      -8109.5103     -8109.5103      318.30143      318.30143      24202.004      24202.004     -496.10519     -496.10519    
    235000  -8025.477      -8025.477      -8110.4314     -8110.4314      328.78246      328.78246      24217.001      24217.001     -1797.0716     -1797.0716    
Loop time of 150.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.677 hours/ns, 6.665 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.5      | 149.5      | 149.5      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095747   | 0.095747   | 0.095747   |   0.0 |  0.06
Output  | 0.00016344 | 0.00016344 | 0.00016344 |   0.0 |  0.00
Modify  | 0.3804     | 0.3804     | 0.3804     |   0.0 |  0.25
Other   |            | 0.0606     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205528 ave      205528 max      205528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205528
Ave neighs/atom = 102.764
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.377857970442, Press = 0.0269643019973428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    235000  -8025.477      -8025.477      -8110.4314     -8110.4314      328.78246      328.78246      24217.001      24217.001     -1797.0716     -1797.0716    
    236000  -8026.0784     -8026.0784     -8112.0181     -8112.0181      332.59562      332.59562      24221.208      24221.208     -2402.3058     -2402.3058    
Loop time of 151.887 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.191 hours/ns, 6.584 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.34     | 151.34     | 151.34     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09754    | 0.09754    | 0.09754    |   0.0 |  0.06
Output  | 0.00016173 | 0.00016173 | 0.00016173 |   0.0 |  0.00
Modify  | 0.38611    | 0.38611    | 0.38611    |   0.0 |  0.25
Other   |            | 0.0611     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205462 ave      205462 max      205462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205462
Ave neighs/atom = 102.731
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.374360759745, Press = -0.0919470713337472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    236000  -8026.0784     -8026.0784     -8112.0181     -8112.0181      332.59562      332.59562      24221.208      24221.208     -2402.3058     -2402.3058    
    237000  -8023.8166     -8023.8166     -8110.7133     -8110.7133      336.29904      336.29904      24233.786      24233.786     -2812.3967     -2812.3967    
Loop time of 150.18 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.717 hours/ns, 6.659 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.64     | 149.64     | 149.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096964   | 0.096964   | 0.096964   |   0.0 |  0.06
Output  | 0.00016068 | 0.00016068 | 0.00016068 |   0.0 |  0.00
Modify  | 0.38104    | 0.38104    | 0.38104    |   0.0 |  0.25
Other   |            | 0.0606     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205206 ave      205206 max      205206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205206
Ave neighs/atom = 102.603
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.37885565695, Press = -0.572433857143811
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    237000  -8023.8166     -8023.8166     -8110.7133     -8110.7133      336.29904      336.29904      24233.786      24233.786     -2812.3967     -2812.3967    
    238000  -8026.3524     -8026.3524     -8110.511      -8110.511       325.70268      325.70268      24189.518      24189.518      423.7113       423.7113     
Loop time of 149.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.440 hours/ns, 6.703 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.65     | 148.65     | 148.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095871   | 0.095871   | 0.095871   |   0.0 |  0.06
Output  | 0.0001642  | 0.0001642  | 0.0001642  |   0.0 |  0.00
Modify  | 0.37534    | 0.37534    | 0.37534    |   0.0 |  0.25
Other   |            | 0.06026    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       204964 ave      204964 max      204964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 204964
Ave neighs/atom = 102.482
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.376812237893, Press = -0.41105785672282
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    238000  -8026.3524     -8026.3524     -8110.511      -8110.511       325.70268      325.70268      24189.518      24189.518      423.7113       423.7113     
    239000  -8024.2781     -8024.2781     -8111.1362     -8111.1362      336.14988      336.14988      24180.688      24180.688      1252.5994      1252.5994    
Loop time of 151.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.102 hours/ns, 6.598 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.03     | 151.03     | 151.03     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09705    | 0.09705    | 0.09705    |   0.0 |  0.06
Output  | 0.00020849 | 0.00020849 | 0.00020849 |   0.0 |  0.00
Modify  | 0.38284    | 0.38284    | 0.38284    |   0.0 |  0.25
Other   |            | 0.06052    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206064 ave      206064 max      206064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206064
Ave neighs/atom = 103.032
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.359077360081, Press = -0.178050010935288
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    239000  -8024.2781     -8024.2781     -8111.1362     -8111.1362      336.14988      336.14988      24180.688      24180.688      1252.5994      1252.5994    
    240000  -8026.8476     -8026.8476     -8109.4221     -8109.4221      319.57199      319.57199      24160.574      24160.574      3005.3268      3005.3268    
Loop time of 148.811 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.336 hours/ns, 6.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    | 148.28     | 148.28     | 148.28     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095206   | 0.095206   | 0.095206   |   0.0 |  0.06
Output  | 0.00016435 | 0.00016435 | 0.00016435 |   0.0 |  0.00
Modify  | 0.37348    | 0.37348    | 0.37348    |   0.0 |  0.25
Other   |            | 0.05994    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206278 ave      206278 max      206278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206278
Ave neighs/atom = 103.139
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.356438708994, Press = -0.0150663246168612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    240000  -8026.8476     -8026.8476     -8109.4221     -8109.4221      319.57199      319.57199      24160.574      24160.574      3005.3268      3005.3268    
    241000  -8021.2096     -8021.2096     -8107.348      -8107.348       333.36431      333.36431      24167.45       24167.45       2964.8042      2964.8042    
Loop time of 148.647 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.291 hours/ns, 6.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    | 148.12     | 148.12     | 148.12     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095884   | 0.095884   | 0.095884   |   0.0 |  0.06
Output  | 0.00028587 | 0.00028587 | 0.00028587 |   0.0 |  0.00
Modify  | 0.37372    | 0.37372    | 0.37372    |   0.0 |  0.25
Other   |            | 0.05969    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206806 ave      206806 max      206806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206806
Ave neighs/atom = 103.403
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.367491191923, Press = 0.21731967624219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    241000  -8021.2096     -8021.2096     -8107.348      -8107.348       333.36431      333.36431      24167.45       24167.45       2964.8042      2964.8042    
    242000  -8025.7965     -8025.7965     -8111.4988     -8111.4988      331.6767       331.6767       24182.75       24182.75       800.67989      800.67989    
Loop time of 150.727 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.869 hours/ns, 6.634 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.19     | 150.19     | 150.19     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096237   | 0.096237   | 0.096237   |   0.0 |  0.06
Output  | 0.00016316 | 0.00016316 | 0.00016316 |   0.0 |  0.00
Modify  | 0.3807     | 0.3807     | 0.3807     |   0.0 |  0.25
Other   |            | 0.06055    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206348 ave      206348 max      206348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206348
Ave neighs/atom = 103.174
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.367254965812, Press = 0.354611800909175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    242000  -8025.7965     -8025.7965     -8111.4988     -8111.4988      331.6767       331.6767       24182.75       24182.75       800.67989      800.67989    
    243000  -8028.7189     -8028.7189     -8112.8599     -8112.8599      325.63451      325.63451      24196.993      24196.993     -798.08344     -798.08344    
Loop time of 149.726 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.591 hours/ns, 6.679 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.19     | 149.19     | 149.19     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096653   | 0.096653   | 0.096653   |   0.0 |  0.06
Output  | 0.00016498 | 0.00016498 | 0.00016498 |   0.0 |  0.00
Modify  | 0.3783     | 0.3783     | 0.3783     |   0.0 |  0.25
Other   |            | 0.06046    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206186 ave      206186 max      206186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206186
Ave neighs/atom = 103.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.361730216601, Press = 0.18498997814005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    243000  -8028.7189     -8028.7189     -8112.8599     -8112.8599      325.63451      325.63451      24196.993      24196.993     -798.08344     -798.08344    
    244000  -8023.1415     -8023.1415     -8108.2753     -8108.2753      329.4764       329.4764       24214.077      24214.077     -1035.6526     -1035.6526    
Loop time of 149.026 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.396 hours/ns, 6.710 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.5      | 148.5      | 148.5      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095987   | 0.095987   | 0.095987   |   0.0 |  0.06
Output  | 0.00016829 | 0.00016829 | 0.00016829 |   0.0 |  0.00
Modify  | 0.37302    | 0.37302    | 0.37302    |   0.0 |  0.25
Other   |            | 0.06013    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206218 ave      206218 max      206218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206218
Ave neighs/atom = 103.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.352269319099, Press = 0.1091104193678
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    244000  -8023.1415     -8023.1415     -8108.2753     -8108.2753      329.4764       329.4764       24214.077      24214.077     -1035.6526     -1035.6526    
    245000  -8026.904      -8026.904      -8111.7586     -8111.7586      328.39581      328.39581      24202.723      24202.723     -1074.6431     -1074.6431    
Loop time of 147.546 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.586 ns/day, 40.985 hours/ns, 6.778 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.02     | 147.02     | 147.02     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095286   | 0.095286   | 0.095286   |   0.0 |  0.06
Output  | 0.00016326 | 0.00016326 | 0.00016326 |   0.0 |  0.00
Modify  | 0.37265    | 0.37265    | 0.37265    |   0.0 |  0.25
Other   |            | 0.05962    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       205290 ave      205290 max      205290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 205290
Ave neighs/atom = 102.645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.355256465771, Press = -0.0319419816962795
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    245000  -8026.904      -8026.904      -8111.7586     -8111.7586      328.39581      328.39581      24202.723      24202.723     -1074.6431     -1074.6431    
    246000  -8025.9177     -8025.9177     -8109.9725     -8109.9725      325.30102      325.30102      24194.545      24194.545      64.957817      64.957817    
Loop time of 151.374 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.048 hours/ns, 6.606 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.83     | 150.83     | 150.83     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097586   | 0.097586   | 0.097586   |   0.0 |  0.06
Output  | 0.00016413 | 0.00016413 | 0.00016413 |   0.0 |  0.00
Modify  | 0.38224    | 0.38224    | 0.38224    |   0.0 |  0.25
Other   |            | 0.06082    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       206024 ave      206024 max      206024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 206024
Ave neighs/atom = 103.012
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
24196.9483551248

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0