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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.613315671682358*${_u_distance}
variable latticeconst_converted equal 3.613315671682358*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331567168236
Lattice spacing in x,y,z = 3.6133157 3.6133157 3.6133157
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133157 36.133157 36.133157)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (36.133157 36.133157 36.133157)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WangOhLee_2020_CuMo__MO_380272712420_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6305927869 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_380272712420_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14029.144     -14029.144     -14160         -14160          253.15         253.15         47175.631      47175.631      2962.7669      2962.7669    
      1000  -13891.154     -13891.154     -14025.485     -14025.485      259.87077      259.87077      47819.315      47819.315      442.31666      442.31666    
Loop time of 99.8744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.865 ns/day, 27.743 hours/ns, 10.013 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.696     | 99.696     | 99.696     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031445   | 0.031445   | 0.031445   |   0.0 |  0.03
Output  | 0.00017609 | 0.00017609 | 0.00017609 |   0.0 |  0.00
Modify  | 0.13046    | 0.13046    | 0.13046    |   0.0 |  0.13
Other   |            | 0.01612    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       704000 ave      704000 max      704000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704000
Ave neighs/atom = 176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13891.154     -13891.154     -14025.485     -14025.485      259.87077      259.87077      47819.315      47819.315      442.31666      442.31666    
      2000  -13900.169     -13900.169     -14032.673     -14032.673      256.33861      256.33861      47811.972      47811.972     -61.728421     -61.728421    
Loop time of 104.677 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.077 hours/ns, 9.553 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.51     | 104.51     | 104.51     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030499   | 0.030499   | 0.030499   |   0.0 |  0.03
Output  | 8.2415e-05 | 8.2415e-05 | 8.2415e-05 |   0.0 |  0.00
Modify  | 0.12534    | 0.12534    | 0.12534    |   0.0 |  0.12
Other   |            | 0.01358    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716158 ave      716158 max      716158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716158
Ave neighs/atom = 179.0395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13900.169     -13900.169     -14032.673     -14032.673      256.33861      256.33861      47811.972      47811.972     -61.728421     -61.728421    
      3000  -13897.662     -13897.662     -14031.622     -14031.622      259.15446      259.15446      47835.404      47835.404     -463.39874     -463.39874    
Loop time of 104.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.120 hours/ns, 9.539 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.66     | 104.66     | 104.66     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030639   | 0.030639   | 0.030639   |   0.0 |  0.03
Output  | 0.00011106 | 0.00011106 | 0.00011106 |   0.0 |  0.00
Modify  | 0.12566    | 0.12566    | 0.12566    |   0.0 |  0.12
Other   |            | 0.01378    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715908 ave      715908 max      715908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715908
Ave neighs/atom = 178.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13897.662     -13897.662     -14031.622     -14031.622      259.15446      259.15446      47835.404      47835.404     -463.39874     -463.39874    
      4000  -13897.892     -13897.892     -14028.238     -14028.238      252.16278      252.16278      47854.41       47854.41      -787.92467     -787.92467    
Loop time of 104.625 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.063 hours/ns, 9.558 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.46     | 104.46     | 104.46     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030535   | 0.030535   | 0.030535   |   0.0 |  0.03
Output  | 8.546e-05  | 8.546e-05  | 8.546e-05  |   0.0 |  0.00
Modify  | 0.12549    | 0.12549    | 0.12549    |   0.0 |  0.12
Other   |            | 0.01374    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715036 ave      715036 max      715036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715036
Ave neighs/atom = 178.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 = 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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13897.892     -13897.892     -14028.238     -14028.238      252.16278      252.16278      47854.41       47854.41      -787.92467     -787.92467    
      5000  -13900.495     -13900.495     -14027.377     -14027.377      245.46265      245.46265      47857.258      47857.258     -765.09412     -765.09412    
Loop time of 104.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.147 hours/ns, 9.530 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.76     | 104.76     | 104.76     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030383   | 0.030383   | 0.030383   |   0.0 |  0.03
Output  | 6.4722e-05 | 6.4722e-05 | 6.4722e-05 |   0.0 |  0.00
Modify  | 0.12583    | 0.12583    | 0.12583    |   0.0 |  0.12
Other   |            | 0.01358    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715534 ave      715534 max      715534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715534
Ave neighs/atom = 178.8835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.404964311389, Press = -50.02868112331
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13900.495     -13900.495     -14027.377     -14027.377      245.46265      245.46265      47857.258      47857.258     -765.09412     -765.09412    
      6000  -13895.302     -13895.302     -14030.37      -14030.37       261.29721      261.29721      47874.139      47874.139     -1380.0529     -1380.0529    
Loop time of 104.9 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.139 hours/ns, 9.533 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.73     | 104.73     | 104.73     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030414   | 0.030414   | 0.030414   |   0.0 |  0.03
Output  | 6.9279e-05 | 6.9279e-05 | 6.9279e-05 |   0.0 |  0.00
Modify  | 0.13053    | 0.13053    | 0.13053    |   0.0 |  0.12
Other   |            | 0.01361    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715224 ave      715224 max      715224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715224
Ave neighs/atom = 178.806
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.675426979734, Press = 10.9561207148495
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13895.302     -13895.302     -14030.37      -14030.37       261.29721      261.29721      47874.139      47874.139     -1380.0529     -1380.0529    
      7000  -13900.818     -13900.818     -14030.162     -14030.162      250.22521      250.22521      47860.016      47860.016     -1100.7322     -1100.7322    
Loop time of 104.706 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.085 hours/ns, 9.551 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.53     | 104.53     | 104.53     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030402   | 0.030402   | 0.030402   |   0.0 |  0.03
Output  | 6.2868e-05 | 6.2868e-05 | 6.2868e-05 |   0.0 |  0.00
Modify  | 0.12952    | 0.12952    | 0.12952    |   0.0 |  0.12
Other   |            | 0.01344    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714790 ave      714790 max      714790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714790
Ave neighs/atom = 178.6975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.062926336908, Press = 8.16224470050601
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13900.818     -13900.818     -14030.162     -14030.162      250.22521      250.22521      47860.016      47860.016     -1100.7322     -1100.7322    
      8000  -13899.619     -13899.619     -14028.371     -14028.371      249.08023      249.08023      47857.003      47857.003     -844.13992     -844.13992    
Loop time of 104.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.149 hours/ns, 9.530 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.76     | 104.76     | 104.76     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030256   | 0.030256   | 0.030256   |   0.0 |  0.03
Output  | 7.1244e-05 | 7.1244e-05 | 7.1244e-05 |   0.0 |  0.00
Modify  | 0.12978    | 0.12978    | 0.12978    |   0.0 |  0.12
Other   |            | 0.01342    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715124 ave      715124 max      715124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715124
Ave neighs/atom = 178.781
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.076891634399, Press = 9.71577639631683
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13899.619     -13899.619     -14028.371     -14028.371      249.08023      249.08023      47857.003      47857.003     -844.13992     -844.13992    
      9000  -13894.193     -13894.193     -14025.313     -14025.313      253.66062      253.66062      47851.931      47851.931     -210.61528     -210.61528    
Loop time of 105.069 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.186 hours/ns, 9.518 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.89     | 104.89     | 104.89     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030713   | 0.030713   | 0.030713   |   0.0 |  0.03
Output  | 7.7595e-05 | 7.7595e-05 | 7.7595e-05 |   0.0 |  0.00
Modify  | 0.13004    | 0.13004    | 0.13004    |   0.0 |  0.12
Other   |            | 0.01348    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715356 ave      715356 max      715356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715356
Ave neighs/atom = 178.839
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.342493648039, Press = 8.70240610399067
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13894.193     -13894.193     -14025.313     -14025.313      253.66062      253.66062      47851.931      47851.931     -210.61528     -210.61528    
     10000  -13896.962     -13896.962     -14026.68      -14026.68       250.94912      250.94912      47840.66       47840.66      -155.9433      -155.9433     
Loop time of 105.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.167 hours/ns, 9.524 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.83     | 104.83     | 104.83     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030695   | 0.030695   | 0.030695   |   0.0 |  0.03
Output  | 6.384e-05  | 6.384e-05  | 6.384e-05  |   0.0 |  0.00
Modify  | 0.12996    | 0.12996    | 0.12996    |   0.0 |  0.12
Other   |            | 0.01341    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715230 ave      715230 max      715230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715230
Ave neighs/atom = 178.8075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.253096525367, Press = 8.98709699293449
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13896.962     -13896.962     -14026.68      -14026.68       250.94912      250.94912      47840.66       47840.66      -155.9433      -155.9433     
     11000  -13900.07      -13900.07      -14029.121     -14029.121      249.65847      249.65847      47811.119      47811.119      347.91693      347.91693    
Loop time of 105.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.168 hours/ns, 9.523 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.83     | 104.83     | 104.83     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030532   | 0.030532   | 0.030532   |   0.0 |  0.03
Output  | 6.2167e-05 | 6.2167e-05 | 6.2167e-05 |   0.0 |  0.00
Modify  | 0.13       | 0.13       | 0.13       |   0.0 |  0.12
Other   |            | 0.01338    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715444 ave      715444 max      715444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715444
Ave neighs/atom = 178.861
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.050301686309, Press = 3.79466217870794
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13900.07      -13900.07      -14029.121     -14029.121      249.65847      249.65847      47811.119      47811.119      347.91693      347.91693    
     12000  -13894.356     -13894.356     -14027.856     -14027.856      258.26509      258.26509      47817.165      47817.165      554.52389      554.52389    
Loop time of 104.929 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.147 hours/ns, 9.530 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.76     | 104.76     | 104.76     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030623   | 0.030623   | 0.030623   |   0.0 |  0.03
Output  | 6.8188e-05 | 6.8188e-05 | 6.8188e-05 |   0.0 |  0.00
Modify  | 0.12975    | 0.12975    | 0.12975    |   0.0 |  0.12
Other   |            | 0.01341    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715854 ave      715854 max      715854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715854
Ave neighs/atom = 178.9635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.121098990125, Press = 2.24813415945583
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13894.356     -13894.356     -14027.856     -14027.856      258.26509      258.26509      47817.165      47817.165      554.52389      554.52389    
     13000  -13899.102     -13899.102     -14029.904     -14029.904      253.04487      253.04487      47778.247      47778.247      1272.6281      1272.6281    
Loop time of 105.204 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.223 hours/ns, 9.505 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.03     | 105.03     | 105.03     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030644   | 0.030644   | 0.030644   |   0.0 |  0.03
Output  | 6.2567e-05 | 6.2567e-05 | 6.2567e-05 |   0.0 |  0.00
Modify  | 0.12979    | 0.12979    | 0.12979    |   0.0 |  0.12
Other   |            | 0.01332    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715526 ave      715526 max      715526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715526
Ave neighs/atom = 178.8815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.199212156452, Press = 1.40326991766776
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13899.102     -13899.102     -14029.904     -14029.904      253.04487      253.04487      47778.247      47778.247      1272.6281      1272.6281    
     14000  -13897.677     -13897.677     -14027.659     -14027.659      251.45866      251.45866      47769.826      47769.826      1708.3128      1708.3128    
Loop time of 105.025 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.174 hours/ns, 9.522 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.85     | 104.85     | 104.85     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03051    | 0.03051    | 0.03051    |   0.0 |  0.03
Output  | 0.00011779 | 0.00011779 | 0.00011779 |   0.0 |  0.00
Modify  | 0.13005    | 0.13005    | 0.13005    |   0.0 |  0.12
Other   |            | 0.01344    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716052 ave      716052 max      716052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716052
Ave neighs/atom = 179.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.407286031788, Press = -0.956183887389372
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13897.677     -13897.677     -14027.659     -14027.659      251.45866      251.45866      47769.826      47769.826      1708.3128      1708.3128    
     15000  -13898.711     -13898.711     -14029.579     -14029.579      253.17363      253.17363      47774.292      47774.292      1492.6918      1492.6918    
Loop time of 105.127 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.202 hours/ns, 9.512 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.95     | 104.95     | 104.95     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030627   | 0.030627   | 0.030627   |   0.0 |  0.03
Output  | 6.2958e-05 | 6.2958e-05 | 6.2958e-05 |   0.0 |  0.00
Modify  | 0.12991    | 0.12991    | 0.12991    |   0.0 |  0.12
Other   |            | 0.01343    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716552 ave      716552 max      716552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716552
Ave neighs/atom = 179.138
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.362240319273, Press = -1.73356383727774
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13898.711     -13898.711     -14029.579     -14029.579      253.17363      253.17363      47774.292      47774.292      1492.6918      1492.6918    
     16000  -13897.932     -13897.932     -14029.163     -14029.163      253.87539      253.87539      47801.385      47801.385      713.19782      713.19782    
Loop time of 104.923 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.145 hours/ns, 9.531 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.75     | 104.75     | 104.75     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030682   | 0.030682   | 0.030682   |   0.0 |  0.03
Output  | 6.4671e-05 | 6.4671e-05 | 6.4671e-05 |   0.0 |  0.00
Modify  | 0.12976    | 0.12976    | 0.12976    |   0.0 |  0.12
Other   |            | 0.01346    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716150 ave      716150 max      716150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716150
Ave neighs/atom = 179.0375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.35650407134, Press = -2.6623177417637
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13897.932     -13897.932     -14029.163     -14029.163      253.87539      253.87539      47801.385      47801.385      713.19782      713.19782    
     17000  -13900.895     -13900.895     -14028.273     -14028.273      246.42287      246.42287      47820.899      47820.899      211.73059      211.73059    
Loop time of 104.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.141 hours/ns, 9.532 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.73     | 104.73     | 104.73     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03071    | 0.03071    | 0.03071    |   0.0 |  0.03
Output  | 6.4241e-05 | 6.4241e-05 | 6.4241e-05 |   0.0 |  0.00
Modify  | 0.13006    | 0.13006    | 0.13006    |   0.0 |  0.12
Other   |            | 0.01335    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715726 ave      715726 max      715726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715726
Ave neighs/atom = 178.9315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.34478426405, Press = -1.47685260718597
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13900.895     -13900.895     -14028.273     -14028.273      246.42287      246.42287      47820.899      47820.899      211.73059      211.73059    
     18000  -13898.71      -13898.71      -14028.995     -14028.995      252.04618      252.04618      47834.01       47834.01      -220.14665     -220.14665    
Loop time of 104.958 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.155 hours/ns, 9.528 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.78     | 104.78     | 104.78     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03058    | 0.03058    | 0.03058    |   0.0 |  0.03
Output  | 6.1986e-05 | 6.1986e-05 | 6.1986e-05 |   0.0 |  0.00
Modify  | 0.13007    | 0.13007    | 0.13007    |   0.0 |  0.12
Other   |            | 0.01346    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715494 ave      715494 max      715494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715494
Ave neighs/atom = 178.8735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.363398076268, Press = -0.480850577909678
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13898.71      -13898.71      -14028.995     -14028.995      252.04618      252.04618      47834.01       47834.01      -220.14665     -220.14665    
     19000  -13893.393     -13893.393     -14023.828     -14023.828      252.33558      252.33558      47847.588      47847.588     -15.783819     -15.783819    
Loop time of 104.775 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.104 hours/ns, 9.544 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.6      | 104.6      | 104.6      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030753   | 0.030753   | 0.030753   |   0.0 |  0.03
Output  | 6.5303e-05 | 6.5303e-05 | 6.5303e-05 |   0.0 |  0.00
Modify  | 0.13026    | 0.13026    | 0.13026    |   0.0 |  0.12
Other   |            | 0.01357    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715674 ave      715674 max      715674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715674
Ave neighs/atom = 178.9185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.333332466379, Press = 0.249370836013838
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13893.393     -13893.393     -14023.828     -14023.828      252.33558      252.33558      47847.588      47847.588     -15.783819     -15.783819    
     20000  -13897.331     -13897.331     -14027.539     -14027.539      251.89611      251.89611      47850.038      47850.038     -516.90575     -516.90575    
Loop time of 104.901 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.139 hours/ns, 9.533 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.73     | 104.73     | 104.73     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030575   | 0.030575   | 0.030575   |   0.0 |  0.03
Output  | 6.2528e-05 | 6.2528e-05 | 6.2528e-05 |   0.0 |  0.00
Modify  | 0.12992    | 0.12992    | 0.12992    |   0.0 |  0.12
Other   |            | 0.01339    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715710 ave      715710 max      715710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715710
Ave neighs/atom = 178.9275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.318177789156, Press = 0.567674470620068
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13897.331     -13897.331     -14027.539     -14027.539      251.89611      251.89611      47850.038      47850.038     -516.90575     -516.90575    
     21000  -13899.066     -13899.066     -14028.436     -14028.436      250.27443      250.27443      47837.424      47837.424     -244.26128     -244.26128    
Loop time of 105.027 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.174 hours/ns, 9.521 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.85     | 104.85     | 104.85     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030739   | 0.030739   | 0.030739   |   0.0 |  0.03
Output  | 6.8438e-05 | 6.8438e-05 | 6.8438e-05 |   0.0 |  0.00
Modify  | 0.13017    | 0.13017    | 0.13017    |   0.0 |  0.12
Other   |            | 0.01344    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715458 ave      715458 max      715458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715458
Ave neighs/atom = 178.8645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.372893791132, Press = 1.67604967764229
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13899.066     -13899.066     -14028.436     -14028.436      250.27443      250.27443      47837.424      47837.424     -244.26128     -244.26128    
     22000  -13895.897     -13895.897     -14028.11      -14028.11       255.77601      255.77601      47822.144      47822.144      282.53991      282.53991    
Loop time of 104.906 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.141 hours/ns, 9.532 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.73     | 104.73     | 104.73     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030628   | 0.030628   | 0.030628   |   0.0 |  0.03
Output  | 8.3406e-05 | 8.3406e-05 | 8.3406e-05 |   0.0 |  0.00
Modify  | 0.12995    | 0.12995    | 0.12995    |   0.0 |  0.12
Other   |            | 0.0134     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715550 ave      715550 max      715550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715550
Ave neighs/atom = 178.8875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.369763196112, Press = 2.72973807426975
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13895.897     -13895.897     -14028.11      -14028.11       255.77601      255.77601      47822.144      47822.144      282.53991      282.53991    
     23000  -13897.943     -13897.943     -14029.265     -14029.265      254.05253      254.05253      47800.169      47800.169      730.86566      730.86566    
Loop time of 104.808 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.113 hours/ns, 9.541 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.63     | 104.63     | 104.63     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030415   | 0.030415   | 0.030415   |   0.0 |  0.03
Output  | 6.3379e-05 | 6.3379e-05 | 6.3379e-05 |   0.0 |  0.00
Modify  | 0.12974    | 0.12974    | 0.12974    |   0.0 |  0.12
Other   |            | 0.0135     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715850 ave      715850 max      715850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715850
Ave neighs/atom = 178.9625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.440561497921, Press = 2.16764772011974
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13897.943     -13897.943     -14029.265     -14029.265      254.05253      254.05253      47800.169      47800.169      730.86566      730.86566    
     24000  -13897.021     -13897.021     -14030.262     -14030.262      257.764        257.764        47814.334      47814.334      239.01644      239.01644    
Loop time of 104.888 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.136 hours/ns, 9.534 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.71     | 104.71     | 104.71     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030494   | 0.030494   | 0.030494   |   0.0 |  0.03
Output  | 6.2106e-05 | 6.2106e-05 | 6.2106e-05 |   0.0 |  0.00
Modify  | 0.12981    | 0.12981    | 0.12981    |   0.0 |  0.12
Other   |            | 0.01347    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715796 ave      715796 max      715796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715796
Ave neighs/atom = 178.949
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.436000389295, Press = 1.01193640149746
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13897.021     -13897.021     -14030.262     -14030.262      257.764        257.764        47814.334      47814.334      239.01644      239.01644    
     25000  -13901.065     -13901.065     -14030.231     -14030.231      249.8799       249.8799       47802.127      47802.127      601.32238      601.32238    
Loop time of 104.992 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.164 hours/ns, 9.525 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.82     | 104.82     | 104.82     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03034    | 0.03034    | 0.03034    |   0.0 |  0.03
Output  | 7.2546e-05 | 7.2546e-05 | 7.2546e-05 |   0.0 |  0.00
Modify  | 0.12962    | 0.12962    | 0.12962    |   0.0 |  0.12
Other   |            | 0.01419    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715452 ave      715452 max      715452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715452
Ave neighs/atom = 178.863
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.473047323657, Press = -0.0292308075669973
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13901.065     -13901.065     -14030.231     -14030.231      249.8799       249.8799       47802.127      47802.127      601.32238      601.32238    
     26000  -13899.449     -13899.449     -14030.049     -14030.049      252.65414      252.65414      47816.693      47816.693      70.923432      70.923432    
Loop time of 104.8 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.111 hours/ns, 9.542 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.63     | 104.63     | 104.63     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029824   | 0.029824   | 0.029824   |   0.0 |  0.03
Output  | 5.894e-05  | 5.894e-05  | 5.894e-05  |   0.0 |  0.00
Modify  | 0.12825    | 0.12825    | 0.12825    |   0.0 |  0.12
Other   |            | 0.01362    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715278 ave      715278 max      715278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715278
Ave neighs/atom = 178.8195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.542710325742, Press = -0.4753936841022
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13899.449     -13899.449     -14030.049     -14030.049      252.65414      252.65414      47816.693      47816.693      70.923432      70.923432    
     27000  -13892.731     -13892.731     -14027.646     -14027.646      261.00235      261.00235      47843.482      47843.482     -245.91659     -245.91659    
Loop time of 104.522 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.034 hours/ns, 9.567 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.35     | 104.35     | 104.35     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029992   | 0.029992   | 0.029992   |   0.0 |  0.03
Output  | 5.324e-05  | 5.324e-05  | 5.324e-05  |   0.0 |  0.00
Modify  | 0.12801    | 0.12801    | 0.12801    |   0.0 |  0.12
Other   |            | 0.01365    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715580 ave      715580 max      715580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715580
Ave neighs/atom = 178.895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.562319028148, Press = -0.266788527881743
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13892.731     -13892.731     -14027.646     -14027.646      261.00235      261.00235      47843.482      47843.482     -245.91659     -245.91659    
     28000  -13899.563     -13899.563     -14028.592     -14028.592      249.61531      249.61531      47825.809      47825.809      35.547421      35.547421    
Loop time of 104.846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.124 hours/ns, 9.538 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.67     | 104.67     | 104.67     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02993    | 0.02993    | 0.02993    |   0.0 |  0.03
Output  | 5.8259e-05 | 5.8259e-05 | 5.8259e-05 |   0.0 |  0.00
Modify  | 0.12774    | 0.12774    | 0.12774    |   0.0 |  0.12
Other   |            | 0.01366    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715258 ave      715258 max      715258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715258
Ave neighs/atom = 178.8145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.588142374233, Press = -0.0409744658674442
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13899.563     -13899.563     -14028.592     -14028.592      249.61531      249.61531      47825.809      47825.809      35.547421      35.547421    
     29000  -13899.536     -13899.536     -14028.626     -14028.626      249.73388      249.73388      47852.387      47852.387     -819.73228     -819.73228    
Loop time of 104.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.103 hours/ns, 9.545 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.6      | 104.6      | 104.6      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029773   | 0.029773   | 0.029773   |   0.0 |  0.03
Output  | 5.9081e-05 | 5.9081e-05 | 5.9081e-05 |   0.0 |  0.00
Modify  | 0.12798    | 0.12798    | 0.12798    |   0.0 |  0.12
Other   |            | 0.01366    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715604 ave      715604 max      715604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715604
Ave neighs/atom = 178.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 = 253.621471274102, Press = 1.11835007969019
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13899.536     -13899.536     -14028.626     -14028.626      249.73388      249.73388      47852.387      47852.387     -819.73228     -819.73228    
     30000  -13896.283     -13896.283     -14028.08      -14028.08       254.97103      254.97103      47858.768      47858.768     -815.45421     -815.45421    
Loop time of 104.859 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.128 hours/ns, 9.537 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.69     | 104.69     | 104.69     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029688   | 0.029688   | 0.029688   |   0.0 |  0.03
Output  | 5.9982e-05 | 5.9982e-05 | 5.9982e-05 |   0.0 |  0.00
Modify  | 0.12803    | 0.12803    | 0.12803    |   0.0 |  0.12
Other   |            | 0.01369    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715420 ave      715420 max      715420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715420
Ave neighs/atom = 178.855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.607861843704, Press = 1.96543515482911
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13896.283     -13896.283     -14028.08      -14028.08       254.97103      254.97103      47858.768      47858.768     -815.45421     -815.45421    
     31000  -13898.049     -13898.049     -14028.414     -14028.414      252.19985      252.19985      47811.168      47811.168      416.11466      416.11466    
Loop time of 104.706 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.085 hours/ns, 9.551 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.53     | 104.53     | 104.53     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029637   | 0.029637   | 0.029637   |   0.0 |  0.03
Output  | 5.313e-05  | 5.313e-05  | 5.313e-05  |   0.0 |  0.00
Modify  | 0.12798    | 0.12798    | 0.12798    |   0.0 |  0.12
Other   |            | 0.0136     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715158 ave      715158 max      715158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715158
Ave neighs/atom = 178.7895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.562103600019, Press = 1.40424679767489
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13898.049     -13898.049     -14028.414     -14028.414      252.19985      252.19985      47811.168      47811.168      416.11466      416.11466    
     32000  -13898.04      -13898.04      -14031.754     -14031.754      258.67991      258.67991      47824.572      47824.572     -198.84801     -198.84801    
Loop time of 104.74 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.094 hours/ns, 9.547 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.57     | 104.57     | 104.57     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029826   | 0.029826   | 0.029826   |   0.0 |  0.03
Output  | 5.7568e-05 | 5.7568e-05 | 5.7568e-05 |   0.0 |  0.00
Modify  | 0.12781    | 0.12781    | 0.12781    |   0.0 |  0.12
Other   |            | 0.01366    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715950 ave      715950 max      715950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715950
Ave neighs/atom = 178.9875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.47573718642, Press = 0.507380225508259
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13898.04      -13898.04      -14031.754     -14031.754      258.67991      258.67991      47824.572      47824.572     -198.84801     -198.84801    
     33000  -13901.027     -13901.027     -14030.637     -14030.637      250.73916      250.73916      47812.391      47812.391      254.88777      254.88777    
Loop time of 104.759 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.100 hours/ns, 9.546 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.59     | 104.59     | 104.59     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029733   | 0.029733   | 0.029733   |   0.0 |  0.03
Output  | 5.8119e-05 | 5.8119e-05 | 5.8119e-05 |   0.0 |  0.00
Modify  | 0.12804    | 0.12804    | 0.12804    |   0.0 |  0.12
Other   |            | 0.01356    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715104 ave      715104 max      715104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715104
Ave neighs/atom = 178.776
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.457083562085, Press = 0.828433885276869
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13901.027     -13901.027     -14030.637     -14030.637      250.73916      250.73916      47812.391      47812.391      254.88777      254.88777    
     34000  -13898.792     -13898.792     -14029.586     -14029.586      253.0311       253.0311       47805.593      47805.593      553.70239      553.70239    
Loop time of 104.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.088 hours/ns, 9.550 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.55     | 104.55     | 104.55     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02972    | 0.02972    | 0.02972    |   0.0 |  0.03
Output  | 5.9943e-05 | 5.9943e-05 | 5.9943e-05 |   0.0 |  0.00
Modify  | 0.12784    | 0.12784    | 0.12784    |   0.0 |  0.12
Other   |            | 0.01367    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715584 ave      715584 max      715584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715584
Ave neighs/atom = 178.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 = 253.445957630813, Press = 0.958972531405226
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13898.792     -13898.792     -14029.586     -14029.586      253.0311       253.0311       47805.593      47805.593      553.70239      553.70239    
     35000  -13895.444     -13895.444     -14026.53      -14026.53       253.59443      253.59443      47738.66       47738.66       2772.6927      2772.6927    
Loop time of 104.74 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.095 hours/ns, 9.547 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.57     | 104.57     | 104.57     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029729   | 0.029729   | 0.029729   |   0.0 |  0.03
Output  | 5.4092e-05 | 5.4092e-05 | 5.4092e-05 |   0.0 |  0.00
Modify  | 0.12785    | 0.12785    | 0.12785    |   0.0 |  0.12
Other   |            | 0.01356    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715842 ave      715842 max      715842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715842
Ave neighs/atom = 178.9605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.50771633279, Press = 1.55042469060028
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13895.444     -13895.444     -14026.53      -14026.53       253.59443      253.59443      47738.66       47738.66       2772.6927      2772.6927    
     36000  -13897.647     -13897.647     -14029.255     -14029.255      254.60497      254.60497      47758.625      47758.625      1965.6809      1965.6809    
Loop time of 104.731 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.092 hours/ns, 9.548 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.56     | 104.56     | 104.56     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029766   | 0.029766   | 0.029766   |   0.0 |  0.03
Output  | 6.3639e-05 | 6.3639e-05 | 6.3639e-05 |   0.0 |  0.00
Modify  | 0.12786    | 0.12786    | 0.12786    |   0.0 |  0.12
Other   |            | 0.0136     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716758 ave      716758 max      716758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716758
Ave neighs/atom = 179.1895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.508348813054, Press = 0.449163251764402
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13897.647     -13897.647     -14029.255     -14029.255      254.60497      254.60497      47758.625      47758.625      1965.6809      1965.6809    
     37000  -13896.765     -13896.765     -14027.599     -14027.599      253.10707      253.10707      47780.187      47780.187      1486.0591      1486.0591    
Loop time of 104.95 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.153 hours/ns, 9.528 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.78     | 104.78     | 104.78     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029715   | 0.029715   | 0.029715   |   0.0 |  0.03
Output  | 6.1305e-05 | 6.1305e-05 | 6.1305e-05 |   0.0 |  0.00
Modify  | 0.12777    | 0.12777    | 0.12777    |   0.0 |  0.12
Other   |            | 0.01355    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716078 ave      716078 max      716078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716078
Ave neighs/atom = 179.0195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.565536926028, Press = -0.0216365398568229
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13896.765     -13896.765     -14027.599     -14027.599      253.10707      253.10707      47780.187      47780.187      1486.0591      1486.0591    
     38000  -13896.865     -13896.865     -14028.785     -14028.785      255.20823      255.20823      47789.916      47789.916      1156.451       1156.451     
Loop time of 104.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.120 hours/ns, 9.539 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.66     | 104.66     | 104.66     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029709   | 0.029709   | 0.029709   |   0.0 |  0.03
Output  | 6.6064e-05 | 6.6064e-05 | 6.6064e-05 |   0.0 |  0.00
Modify  | 0.1278     | 0.1278     | 0.1278     |   0.0 |  0.12
Other   |            | 0.01363    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716068 ave      716068 max      716068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716068
Ave neighs/atom = 179.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 = 253.564315962866, Press = 0.142634798000769
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13896.865     -13896.865     -14028.785     -14028.785      255.20823      255.20823      47789.916      47789.916      1156.451       1156.451     
     39000  -13896.205     -13896.205     -14028.217     -14028.217      255.38641      255.38641      47783.149      47783.149      1436.4134      1436.4134    
Loop time of 104.715 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.088 hours/ns, 9.550 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.54     | 104.54     | 104.54     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029708   | 0.029708   | 0.029708   |   0.0 |  0.03
Output  | 5.5404e-05 | 5.5404e-05 | 5.5404e-05 |   0.0 |  0.00
Modify  | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.12
Other   |            | 0.01347    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715800 ave      715800 max      715800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715800
Ave neighs/atom = 178.95
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.55030891535, Press = 0.0717780323066998
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13896.205     -13896.205     -14028.217     -14028.217      255.38641      255.38641      47783.149      47783.149      1436.4134      1436.4134    
     40000  -13899.787     -13899.787     -14030.126     -14030.126      252.14924      252.14924      47796.585      47796.585      711.98051      711.98051    
Loop time of 104.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.101 hours/ns, 9.545 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.59     | 104.59     | 104.59     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029795   | 0.029795   | 0.029795   |   0.0 |  0.03
Output  | 6.0774e-05 | 6.0774e-05 | 6.0774e-05 |   0.0 |  0.00
Modify  | 0.12795    | 0.12795    | 0.12795    |   0.0 |  0.12
Other   |            | 0.01348    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716060 ave      716060 max      716060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716060
Ave neighs/atom = 179.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.501332921765, Press = -0.189557521013398
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13899.787     -13899.787     -14030.126     -14030.126      252.14924      252.14924      47796.585      47796.585      711.98051      711.98051    
     41000  -13899.076     -13899.076     -14029.829     -14029.829      252.95132      252.95132      47819.609      47819.609      171.39167      171.39167    
Loop time of 104.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.128 hours/ns, 9.537 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.69     | 104.69     | 104.69     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029848   | 0.029848   | 0.029848   |   0.0 |  0.03
Output  | 6.3099e-05 | 6.3099e-05 | 6.3099e-05 |   0.0 |  0.00
Modify  | 0.12787    | 0.12787    | 0.12787    |   0.0 |  0.12
Other   |            | 0.01345    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715866 ave      715866 max      715866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715866
Ave neighs/atom = 178.9665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.506265508157, Press = -0.429621559179947
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13899.076     -13899.076     -14029.829     -14029.829      252.95132      252.95132      47819.609      47819.609      171.39167      171.39167    
     42000  -13894.29      -13894.29      -14027.469     -14027.469      257.64446      257.64446      47835.928      47835.928     -58.802352     -58.802352    
Loop time of 104.657 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.071 hours/ns, 9.555 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.49     | 104.49     | 104.49     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029818   | 0.029818   | 0.029818   |   0.0 |  0.03
Output  | 6.1185e-05 | 6.1185e-05 | 6.1185e-05 |   0.0 |  0.00
Modify  | 0.12773    | 0.12773    | 0.12773    |   0.0 |  0.12
Other   |            | 0.01342    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715540 ave      715540 max      715540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715540
Ave neighs/atom = 178.885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.502762214728, Press = -0.167968113413567
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13894.29      -13894.29      -14027.469     -14027.469      257.64446      257.64446      47835.928      47835.928     -58.802352     -58.802352    
     43000  -13898.119     -13898.119     -14029.33      -14029.33       253.83646      253.83646      47820.319      47820.319      248.73301      248.73301    
Loop time of 104.938 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.149 hours/ns, 9.529 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.76     | 104.76     | 104.76     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030116   | 0.030116   | 0.030116   |   0.0 |  0.03
Output  | 0.00013087 | 0.00013087 | 0.00013087 |   0.0 |  0.00
Modify  | 0.12869    | 0.12869    | 0.12869    |   0.0 |  0.12
Other   |            | 0.01419    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715318 ave      715318 max      715318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715318
Ave neighs/atom = 178.8295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.505366634947, Press = -0.220245371000135
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13898.119     -13898.119     -14029.33      -14029.33       253.83646      253.83646      47820.319      47820.319      248.73301      248.73301    
     44000  -13895.964     -13895.964     -14028.335     -14028.335      256.08212      256.08212      47835.895      47835.895     -76.074811     -76.074811    
Loop time of 105.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.172 hours/ns, 9.522 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.84     | 104.84     | 104.84     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030372   | 0.030372   | 0.030372   |   0.0 |  0.03
Output  | 5.9882e-05 | 5.9882e-05 | 5.9882e-05 |   0.0 |  0.00
Modify  | 0.13048    | 0.13048    | 0.13048    |   0.0 |  0.12
Other   |            | 0.01505    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715140 ave      715140 max      715140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715140
Ave neighs/atom = 178.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 = 253.540023786022, Press = -0.89929407772742
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13895.964     -13895.964     -14028.335     -14028.335      256.08212      256.08212      47835.895      47835.895     -76.074811     -76.074811    
     45000  -13897.267     -13897.267     -14030.214     -14030.214      257.19578      257.19578      47852.717      47852.717     -754.51376     -754.51376    
Loop time of 104.818 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.116 hours/ns, 9.540 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.64     | 104.64     | 104.64     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030327   | 0.030327   | 0.030327   |   0.0 |  0.03
Output  | 6.3439e-05 | 6.3439e-05 | 6.3439e-05 |   0.0 |  0.00
Modify  | 0.13065    | 0.13065    | 0.13065    |   0.0 |  0.12
Other   |            | 0.01488    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715460 ave      715460 max      715460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715460
Ave neighs/atom = 178.865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.54523234432, Press = -0.803245117755751
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13897.267     -13897.267     -14030.214     -14030.214      257.19578      257.19578      47852.717      47852.717     -754.51376     -754.51376    
     46000  -13902.448     -13902.448     -14031.251     -14031.251      249.17982      249.17982      47846.612      47846.612     -889.00666     -889.00666    
Loop time of 104.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.136 hours/ns, 9.534 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.71     | 104.71     | 104.71     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030081   | 0.030081   | 0.030081   |   0.0 |  0.03
Output  | 6.398e-05  | 6.398e-05  | 6.398e-05  |   0.0 |  0.00
Modify  | 0.12987    | 0.12987    | 0.12987    |   0.0 |  0.12
Other   |            | 0.01481    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715034 ave      715034 max      715034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715034
Ave neighs/atom = 178.7585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.556796152199, Press = -0.838633872951029
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13902.448     -13902.448     -14031.251     -14031.251      249.17982      249.17982      47846.612      47846.612     -889.00666     -889.00666    
     47000  -13897.63      -13897.63      -14027.366     -14027.366      250.9823       250.9823       47892.332      47892.332     -1738.7792     -1738.7792    
Loop time of 104.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.032 hours/ns, 9.568 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.34     | 104.34     | 104.34     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030525   | 0.030525   | 0.030525   |   0.0 |  0.03
Output  | 5.6886e-05 | 5.6886e-05 | 5.6886e-05 |   0.0 |  0.00
Modify  | 0.13066    | 0.13066    | 0.13066    |   0.0 |  0.13
Other   |            | 0.01491    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715044 ave      715044 max      715044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715044
Ave neighs/atom = 178.761
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.514015488733, Press = -0.39780295969516
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13897.63      -13897.63      -14027.366     -14027.366      250.9823       250.9823       47892.332      47892.332     -1738.7792     -1738.7792    
     48000  -13897.443     -13897.443     -14027.694     -14027.694      251.97897      251.97897      47915.48       47915.48      -2413.4687     -2413.4687    
Loop time of 104.704 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.085 hours/ns, 9.551 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.53     | 104.53     | 104.53     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03002    | 0.03002    | 0.03002    |   0.0 |  0.03
Output  | 6.3089e-05 | 6.3089e-05 | 6.3089e-05 |   0.0 |  0.00
Modify  | 0.12981    | 0.12981    | 0.12981    |   0.0 |  0.12
Other   |            | 0.01394    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714914 ave      714914 max      714914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714914
Ave neighs/atom = 178.7285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.530117610278, Press = 0.460679647038828
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13897.443     -13897.443     -14027.694     -14027.694      251.97897      251.97897      47915.48       47915.48      -2413.4687     -2413.4687    
     49000  -13894.881     -13894.881     -14028.476     -14028.476      258.45027      258.45027      47870.569      47870.569     -1222.0251     -1222.0251    
Loop time of 104.855 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.126 hours/ns, 9.537 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.68     | 104.68     | 104.68     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030289   | 0.030289   | 0.030289   |   0.0 |  0.03
Output  | 5.5324e-05 | 5.5324e-05 | 5.5324e-05 |   0.0 |  0.00
Modify  | 0.13032    | 0.13032    | 0.13032    |   0.0 |  0.12
Other   |            | 0.01504    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714644 ave      714644 max      714644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714644
Ave neighs/atom = 178.661
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.536550600925, Press = 0.682108905272292
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13894.881     -13894.881     -14028.476     -14028.476      258.45027      258.45027      47870.569      47870.569     -1222.0251     -1222.0251    
     50000  -13898.549     -13898.549     -14029.862     -14029.862      254.03378      254.03378      47833.506      47833.506     -266.04006     -266.04006    
Loop time of 104.809 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.114 hours/ns, 9.541 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.63     | 104.63     | 104.63     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030165   | 0.030165   | 0.030165   |   0.0 |  0.03
Output  | 0.00014868 | 0.00014868 | 0.00014868 |   0.0 |  0.00
Modify  | 0.12997    | 0.12997    | 0.12997    |   0.0 |  0.12
Other   |            | 0.01404    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714944 ave      714944 max      714944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714944
Ave neighs/atom = 178.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 = 253.567607662268, Press = 0.384587563168945
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13898.549     -13898.549     -14029.862     -14029.862      254.03378      254.03378      47833.506      47833.506     -266.04006     -266.04006    
     51000  -13895.418     -13895.418     -14027.938     -14027.938      256.36921      256.36921      47829.657      47829.657      145.68779      145.68779    
Loop time of 104.772 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.103 hours/ns, 9.545 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.6      | 104.6      | 104.6      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030329   | 0.030329   | 0.030329   |   0.0 |  0.03
Output  | 5.7748e-05 | 5.7748e-05 | 5.7748e-05 |   0.0 |  0.00
Modify  | 0.13056    | 0.13056    | 0.13056    |   0.0 |  0.12
Other   |            | 0.01448    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715254 ave      715254 max      715254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715254
Ave neighs/atom = 178.8135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.562527700999, Press = 0.1412074552514
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13895.418     -13895.418     -14027.938     -14027.938      256.36921      256.36921      47829.657      47829.657      145.68779      145.68779    
     52000  -13900.371     -13900.371     -14027.931     -14027.931      246.77481      246.77481      47808.126      47808.126      623.63804      623.63804    
Loop time of 104.816 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.116 hours/ns, 9.541 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.64     | 104.64     | 104.64     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029756   | 0.029756   | 0.029756   |   0.0 |  0.03
Output  | 0.00011471 | 0.00011471 | 0.00011471 |   0.0 |  0.00
Modify  | 0.12962    | 0.12962    | 0.12962    |   0.0 |  0.12
Other   |            | 0.01331    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715578 ave      715578 max      715578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715578
Ave neighs/atom = 178.8945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.58786343181, Press = 0.198411094017752
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13900.371     -13900.371     -14027.931     -14027.931      246.77481      246.77481      47808.126      47808.126      623.63804      623.63804    
     53000  -13896.731     -13896.731     -14029.25      -14029.25       256.36635      256.36635      47811.693      47811.693      394.53011      394.53011    
Loop time of 104.927 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.146 hours/ns, 9.530 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.75     | 104.75     | 104.75     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029816   | 0.029816   | 0.029816   |   0.0 |  0.03
Output  | 6.2547e-05 | 6.2547e-05 | 6.2547e-05 |   0.0 |  0.00
Modify  | 0.12984    | 0.12984    | 0.12984    |   0.0 |  0.12
Other   |            | 0.01424    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715708 ave      715708 max      715708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715708
Ave neighs/atom = 178.927
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.584606655682, Press = 0.0775934517297719
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13896.731     -13896.731     -14029.25      -14029.25       256.36635      256.36635      47811.693      47811.693      394.53011      394.53011    
     54000  -13897.106     -13897.106     -14026.856     -14026.856      251.01132      251.01132      47803.39       47803.39       906.71351      906.71351    
Loop time of 104.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.150 hours/ns, 9.529 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.77     | 104.77     | 104.77     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029726   | 0.029726   | 0.029726   |   0.0 |  0.03
Output  | 6.0884e-05 | 6.0884e-05 | 6.0884e-05 |   0.0 |  0.00
Modify  | 0.12937    | 0.12937    | 0.12937    |   0.0 |  0.12
Other   |            | 0.01368    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716092 ave      716092 max      716092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716092
Ave neighs/atom = 179.023
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.542955664071, Press = -0.0771341484774363
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13897.106     -13897.106     -14026.856     -14026.856      251.01132      251.01132      47803.39       47803.39       906.71351      906.71351    
     55000  -13899.488     -13899.488     -14029.569     -14029.569      251.65081      251.65081      47797.829      47797.829      713.37794      713.37794    
Loop time of 104.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.137 hours/ns, 9.533 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.72     | 104.72     | 104.72     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029819   | 0.029819   | 0.029819   |   0.0 |  0.03
Output  | 5.6386e-05 | 5.6386e-05 | 5.6386e-05 |   0.0 |  0.00
Modify  | 0.12982    | 0.12982    | 0.12982    |   0.0 |  0.12
Other   |            | 0.01406    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715838 ave      715838 max      715838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715838
Ave neighs/atom = 178.9595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.532063454162, Press = -0.449637621551486
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13899.488     -13899.488     -14029.569     -14029.569      251.65081      251.65081      47797.829      47797.829      713.37794      713.37794    
     56000  -13893.993     -13893.993     -14026.276     -14026.276      255.9093       255.9093       47815.556      47815.556      654.53326      654.53326    
Loop time of 104.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.161 hours/ns, 9.526 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.81     | 104.81     | 104.81     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029744   | 0.029744   | 0.029744   |   0.0 |  0.03
Output  | 5.9211e-05 | 5.9211e-05 | 5.9211e-05 |   0.0 |  0.00
Modify  | 0.12945    | 0.12945    | 0.12945    |   0.0 |  0.12
Other   |            | 0.01452    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715640 ave      715640 max      715640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715640
Ave neighs/atom = 178.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 = 253.545015815653, Press = -0.645547661920547
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13893.993     -13893.993     -14026.276     -14026.276      255.9093       255.9093       47815.556      47815.556      654.53326      654.53326    
     57000  -13900.986     -13900.986     -14030.062     -14030.062      249.70622      249.70622      47826.494      47826.494     -153.87494     -153.87494    
Loop time of 104.665 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.074 hours/ns, 9.554 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.49     | 104.49     | 104.49     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029606   | 0.029606   | 0.029606   |   0.0 |  0.03
Output  | 5.5635e-05 | 5.5635e-05 | 5.5635e-05 |   0.0 |  0.00
Modify  | 0.12911    | 0.12911    | 0.12911    |   0.0 |  0.12
Other   |            | 0.01371    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715624 ave      715624 max      715624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715624
Ave neighs/atom = 178.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 = 253.544386309322, Press = -1.18088959727829
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13900.986     -13900.986     -14030.062     -14030.062      249.70622      249.70622      47826.494      47826.494     -153.87494     -153.87494    
     58000  -13899.455     -13899.455     -14029.987     -14029.987      252.52378      252.52378      47845.981      47845.981     -686.02155     -686.02155    
Loop time of 104.623 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.062 hours/ns, 9.558 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.45     | 104.45     | 104.45     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02984    | 0.02984    | 0.02984    |   0.0 |  0.03
Output  | 5.4271e-05 | 5.4271e-05 | 5.4271e-05 |   0.0 |  0.00
Modify  | 0.12924    | 0.12924    | 0.12924    |   0.0 |  0.12
Other   |            | 0.01376    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715426 ave      715426 max      715426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715426
Ave neighs/atom = 178.8565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.552364938488, Press = -0.763044616206792
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13899.455     -13899.455     -14029.987     -14029.987      252.52378      252.52378      47845.981      47845.981     -686.02155     -686.02155    
     59000  -13902.183     -13902.183     -14031.26      -14031.26       249.70822      249.70822      47844.86       47844.86      -891.6027      -891.6027     
Loop time of 104.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.128 hours/ns, 9.536 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.69     | 104.69     | 104.69     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030313   | 0.030313   | 0.030313   |   0.0 |  0.03
Output  | 6.1826e-05 | 6.1826e-05 | 6.1826e-05 |   0.0 |  0.00
Modify  | 0.1305     | 0.1305     | 0.1305     |   0.0 |  0.12
Other   |            | 0.01459    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715322 ave      715322 max      715322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715322
Ave neighs/atom = 178.8305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.56035217512, Press = -0.499972927694124
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13902.183     -13902.183     -14031.26      -14031.26       249.70822      249.70822      47844.86       47844.86      -891.6027      -891.6027     
     60000  -13897.407     -13897.407     -14029.345     -14029.345      255.2422       255.2422       47859.335      47859.335     -970.11683     -970.11683    
Loop time of 104.757 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.099 hours/ns, 9.546 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.58     | 104.58     | 104.58     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029587   | 0.029587   | 0.029587   |   0.0 |  0.03
Output  | 5.1547e-05 | 5.1547e-05 | 5.1547e-05 |   0.0 |  0.00
Modify  | 0.12937    | 0.12937    | 0.12937    |   0.0 |  0.12
Other   |            | 0.0137     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715280 ave      715280 max      715280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715280
Ave neighs/atom = 178.82
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.55018961614, Press = -0.333543798755934
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13897.407     -13897.407     -14029.345     -14029.345      255.2422       255.2422       47859.335      47859.335     -970.11683     -970.11683    
     61000  -13901.441     -13901.441     -14029.299     -14029.299      247.35084      247.35084      47865.998      47865.998     -1265.9433     -1265.9433    
Loop time of 104.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.147 hours/ns, 9.530 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.75     | 104.75     | 104.75     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029909   | 0.029909   | 0.029909   |   0.0 |  0.03
Output  | 5.4673e-05 | 5.4673e-05 | 5.4673e-05 |   0.0 |  0.00
Modify  | 0.12919    | 0.12919    | 0.12919    |   0.0 |  0.12
Other   |            | 0.01481    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715166 ave      715166 max      715166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715166
Ave neighs/atom = 178.7915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.507622971747, Press = -0.131097696675545
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13901.441     -13901.441     -14029.299     -14029.299      247.35084      247.35084      47865.998      47865.998     -1265.9433     -1265.9433    
     62000  -13898.844     -13898.844     -14028.963     -14028.963      251.72244      251.72244      47874.972      47874.972     -1338.6169     -1338.6169    
Loop time of 104.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.164 hours/ns, 9.525 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.82     | 104.82     | 104.82     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029836   | 0.029836   | 0.029836   |   0.0 |  0.03
Output  | 6.5573e-05 | 6.5573e-05 | 6.5573e-05 |   0.0 |  0.00
Modify  | 0.12978    | 0.12978    | 0.12978    |   0.0 |  0.12
Other   |            | 0.01465    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714972 ave      714972 max      714972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714972
Ave neighs/atom = 178.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 = 253.497543813575, Press = 0.183315875976402
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13898.844     -13898.844     -14028.963     -14028.963      251.72244      251.72244      47874.972      47874.972     -1338.6169     -1338.6169    
     63000  -13898.002     -13898.002     -14027.65      -14027.65       250.81227      250.81227      47885.033      47885.033     -1535.2172     -1535.2172    
Loop time of 104.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.046 hours/ns, 9.563 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.39     | 104.39     | 104.39     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029744   | 0.029744   | 0.029744   |   0.0 |  0.03
Output  | 5.5734e-05 | 5.5734e-05 | 5.5734e-05 |   0.0 |  0.00
Modify  | 0.12906    | 0.12906    | 0.12906    |   0.0 |  0.12
Other   |            | 0.01333    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715044 ave      715044 max      715044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715044
Ave neighs/atom = 178.761
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.506396436368, Press = 0.448990755380013
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13898.002     -13898.002     -14027.65      -14027.65       250.81227      250.81227      47885.033      47885.033     -1535.2172     -1535.2172    
     64000  -13900.895     -13900.895     -14032.084     -14032.084      253.79429      253.79429      47856.605      47856.605     -1171.577      -1171.577     
Loop time of 104.851 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.125 hours/ns, 9.537 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.68     | 104.68     | 104.68     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029975   | 0.029975   | 0.029975   |   0.0 |  0.03
Output  | 5.3861e-05 | 5.3861e-05 | 5.3861e-05 |   0.0 |  0.00
Modify  | 0.1294     | 0.1294     | 0.1294     |   0.0 |  0.12
Other   |            | 0.01426    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714844 ave      714844 max      714844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714844
Ave neighs/atom = 178.711
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.509649583474, Press = 0.233247723978059
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13900.895     -13900.895     -14032.084     -14032.084      253.79429      253.79429      47856.605      47856.605     -1171.577      -1171.577     
     65000  -13899.109     -13899.109     -14030.12      -14030.12       253.44827      253.44827      47832.239      47832.239     -275.13184     -275.13184    
Loop time of 104.561 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.045 hours/ns, 9.564 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.39     | 104.39     | 104.39     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029672   | 0.029672   | 0.029672   |   0.0 |  0.03
Output  | 6.0594e-05 | 6.0594e-05 | 6.0594e-05 |   0.0 |  0.00
Modify  | 0.12928    | 0.12928    | 0.12928    |   0.0 |  0.12
Other   |            | 0.01367    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715058 ave      715058 max      715058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715058
Ave neighs/atom = 178.7645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.490872438951, Press = 0.219078759868296
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13899.109     -13899.109     -14030.12      -14030.12       253.44827      253.44827      47832.239      47832.239     -275.13184     -275.13184    
     66000  -13895.343     -13895.343     -14025.837     -14025.837      252.44827      252.44827      47836.735      47836.735      43.004617      43.004617    
Loop time of 104.781 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.106 hours/ns, 9.544 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.61     | 104.61     | 104.61     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029847   | 0.029847   | 0.029847   |   0.0 |  0.03
Output  | 5.9822e-05 | 5.9822e-05 | 5.9822e-05 |   0.0 |  0.00
Modify  | 0.12955    | 0.12955    | 0.12955    |   0.0 |  0.12
Other   |            | 0.01462    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715300 ave      715300 max      715300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715300
Ave neighs/atom = 178.825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.466423523054, Press = 0.29681341959304
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13895.343     -13895.343     -14025.837     -14025.837      252.44827      252.44827      47836.735      47836.735      43.004617      43.004617    
     67000  -13898.998     -13898.998     -14029.58      -14029.58       252.61943      252.61943      47825.87       47825.87       12.486554      12.486554    
Loop time of 104.925 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.146 hours/ns, 9.531 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.75     | 104.75     | 104.75     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029947   | 0.029947   | 0.029947   |   0.0 |  0.03
Output  | 5.4101e-05 | 5.4101e-05 | 5.4101e-05 |   0.0 |  0.00
Modify  | 0.12998    | 0.12998    | 0.12998    |   0.0 |  0.12
Other   |            | 0.01406    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715474 ave      715474 max      715474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715474
Ave neighs/atom = 178.8685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.497082811533, Press = 0.473267554187847
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13898.998     -13898.998     -14029.58      -14029.58       252.61943      252.61943      47825.87       47825.87       12.486554      12.486554    
     68000  -13897.488     -13897.488     -14029.146     -14029.146      254.70196      254.70196      47802.981      47802.981      726.44002      726.44002    
Loop time of 104.761 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.100 hours/ns, 9.546 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.59     | 104.59     | 104.59     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029804   | 0.029804   | 0.029804   |   0.0 |  0.03
Output  | 0.00010026 | 0.00010026 | 0.00010026 |   0.0 |  0.00
Modify  | 0.12929    | 0.12929    | 0.12929    |   0.0 |  0.12
Other   |            | 0.01389    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715298 ave      715298 max      715298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715298
Ave neighs/atom = 178.8245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.48959711757, Press = 1.11471138025877
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13897.488     -13897.488     -14029.146     -14029.146      254.70196      254.70196      47802.981      47802.981      726.44002      726.44002    
     69000  -13898.981     -13898.981     -14029.654     -14029.654      252.79754      252.79754      47778.552      47778.552      1369.581       1369.581     
Loop time of 104.877 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.132 hours/ns, 9.535 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.7      | 104.7      | 104.7      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030012   | 0.030012   | 0.030012   |   0.0 |  0.03
Output  | 5.322e-05  | 5.322e-05  | 5.322e-05  |   0.0 |  0.00
Modify  | 0.12944    | 0.12944    | 0.12944    |   0.0 |  0.12
Other   |            | 0.01391    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715938 ave      715938 max      715938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715938
Ave neighs/atom = 178.9845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.491584236166, Press = 0.786501453919797
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13898.981     -13898.981     -14029.654     -14029.654      252.79754      252.79754      47778.552      47778.552      1369.581       1369.581     
     70000  -13898.005     -13898.005     -14029.571     -14029.571      254.5228       254.5228       47806.711      47806.711      536.34011      536.34011    
Loop time of 104.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.105 hours/ns, 9.544 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.61     | 104.61     | 104.61     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030003   | 0.030003   | 0.030003   |   0.0 |  0.03
Output  | 6.3208e-05 | 6.3208e-05 | 6.3208e-05 |   0.0 |  0.00
Modify  | 0.12975    | 0.12975    | 0.12975    |   0.0 |  0.12
Other   |            | 0.0142     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715974 ave      715974 max      715974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715974
Ave neighs/atom = 178.9935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.471572609796, Press = 0.253684035910021
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13898.005     -13898.005     -14029.571     -14029.571      254.5228       254.5228       47806.711      47806.711      536.34011      536.34011    
     71000  -13898.2       -13898.2       -14029.238     -14029.238      253.50168      253.50168      47799.08       47799.08       755.7388       755.7388     
Loop time of 104.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.094 hours/ns, 9.548 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.56     | 104.56     | 104.56     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029778   | 0.029778   | 0.029778   |   0.0 |  0.03
Output  | 5.2078e-05 | 5.2078e-05 | 5.2078e-05 |   0.0 |  0.00
Modify  | 0.12927    | 0.12927    | 0.12927    |   0.0 |  0.12
Other   |            | 0.01451    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715766 ave      715766 max      715766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715766
Ave neighs/atom = 178.9415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.468820562282, Press = 0.305339771542191
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13898.2       -13898.2       -14029.238     -14029.238      253.50168      253.50168      47799.08       47799.08       755.7388       755.7388     
     72000  -13895.822     -13895.822     -14029.602     -14029.602      258.80662      258.80662      47785.919      47785.919      1210.4261      1210.4261    
Loop time of 104.926 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.146 hours/ns, 9.530 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.75     | 104.75     | 104.75     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030195   | 0.030195   | 0.030195   |   0.0 |  0.03
Output  | 5.3821e-05 | 5.3821e-05 | 5.3821e-05 |   0.0 |  0.00
Modify  | 0.13033    | 0.13033    | 0.13033    |   0.0 |  0.12
Other   |            | 0.0145     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716016 ave      716016 max      716016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716016
Ave neighs/atom = 179.004
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.469686249023, Press = 0.277542495907947
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13895.822     -13895.822     -14029.602     -14029.602      258.80662      258.80662      47785.919      47785.919      1210.4261      1210.4261    
     73000  -13899.789     -13899.789     -14028.229     -14028.229      248.47653      248.47653      47743.128      47743.128      2474.5893      2474.5893    
Loop time of 104.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.050 hours/ns, 9.562 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.41     | 104.41     | 104.41     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029621   | 0.029621   | 0.029621   |   0.0 |  0.03
Output  | 5.2849e-05 | 5.2849e-05 | 5.2849e-05 |   0.0 |  0.00
Modify  | 0.12986    | 0.12986    | 0.12986    |   0.0 |  0.12
Other   |            | 0.01371    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715936 ave      715936 max      715936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715936
Ave neighs/atom = 178.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 = 253.453596707707, Press = 0.237858989285658
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13899.789     -13899.789     -14028.229     -14028.229      248.47653      248.47653      47743.128      47743.128      2474.5893      2474.5893    
     74000  -13900.635     -13900.635     -14030.262     -14030.262      250.77219      250.77219      47746.462      47746.462      2207.2927      2207.2927    
Loop time of 104.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.143 hours/ns, 9.532 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.74     | 104.74     | 104.74     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029959   | 0.029959   | 0.029959   |   0.0 |  0.03
Output  | 5.6536e-05 | 5.6536e-05 | 5.6536e-05 |   0.0 |  0.00
Modify  | 0.12977    | 0.12977    | 0.12977    |   0.0 |  0.12
Other   |            | 0.01426    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716548 ave      716548 max      716548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716548
Ave neighs/atom = 179.137
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.450758331699, Press = -0.327859405537544
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13900.635     -13900.635     -14030.262     -14030.262      250.77219      250.77219      47746.462      47746.462      2207.2927      2207.2927    
     75000  -13899.107     -13899.107     -14030.766     -14030.766      254.70286      254.70286      47792.464      47792.464      749.32937      749.32937    
Loop time of 104.843 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.123 hours/ns, 9.538 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.67     | 104.67     | 104.67     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029868   | 0.029868   | 0.029868   |   0.0 |  0.03
Output  | 9.9757e-05 | 9.9757e-05 | 9.9757e-05 |   0.0 |  0.00
Modify  | 0.12899    | 0.12899    | 0.12899    |   0.0 |  0.12
Other   |            | 0.01444    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716352 ave      716352 max      716352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716352
Ave neighs/atom = 179.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.450968417233, Press = -0.229095739210408
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -13899.107     -13899.107     -14030.766     -14030.766      254.70286      254.70286      47792.464      47792.464      749.32937      749.32937    
     76000  -13898.789     -13898.789     -14030.789     -14030.789      255.3623       255.3623       47818.083      47818.083      47.143321      47.143321    
Loop time of 104.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.125 hours/ns, 9.538 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.67     | 104.67     | 104.67     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029966   | 0.029966   | 0.029966   |   0.0 |  0.03
Output  | 5.6446e-05 | 5.6446e-05 | 5.6446e-05 |   0.0 |  0.00
Modify  | 0.13011    | 0.13011    | 0.13011    |   0.0 |  0.12
Other   |            | 0.01425    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715810 ave      715810 max      715810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715810
Ave neighs/atom = 178.9525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.463564032531, Press = -0.136657359494192
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -13898.789     -13898.789     -14030.789     -14030.789      255.3623       255.3623       47818.083      47818.083      47.143321      47.143321    
     77000  -13898.335     -13898.335     -14029.366     -14029.366      253.48879      253.48879      47821.004      47821.004      33.848906      33.848906    
Loop time of 104.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.128 hours/ns, 9.536 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.69     | 104.69     | 104.69     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029808   | 0.029808   | 0.029808   |   0.0 |  0.03
Output  | 5.344e-05  | 5.344e-05  | 5.344e-05  |   0.0 |  0.00
Modify  | 0.12919    | 0.12919    | 0.12919    |   0.0 |  0.12
Other   |            | 0.01456    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715718 ave      715718 max      715718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715718
Ave neighs/atom = 178.9295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.456048639015, Press = -0.00632597472447914
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -13898.335     -13898.335     -14029.366     -14029.366      253.48879      253.48879      47821.004      47821.004      33.848906      33.848906    
     78000  -13902.253     -13902.253     -14029.488     -14029.488      246.1446       246.1446       47825.876      47825.876     -203.32714     -203.32714    
Loop time of 104.621 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.061 hours/ns, 9.558 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.45     | 104.45     | 104.45     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029857   | 0.029857   | 0.029857   |   0.0 |  0.03
Output  | 0.00011865 | 0.00011865 | 0.00011865 |   0.0 |  0.00
Modify  | 0.12911    | 0.12911    | 0.12911    |   0.0 |  0.12
Other   |            | 0.0139     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715864 ave      715864 max      715864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715864
Ave neighs/atom = 178.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 = 253.437599322557, Press = 0.0269278025559905
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -13902.253     -13902.253     -14029.488     -14029.488      246.1446       246.1446       47825.876      47825.876     -203.32714     -203.32714    
     79000  -13896.291     -13896.291     -14025.693     -14025.693      250.33803      250.33803      47853.862      47853.862     -440.7057      -440.7057     
Loop time of 104.872 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.131 hours/ns, 9.535 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.7      | 104.7      | 104.7      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030299   | 0.030299   | 0.030299   |   0.0 |  0.03
Output  | 5.9752e-05 | 5.9752e-05 | 5.9752e-05 |   0.0 |  0.00
Modify  | 0.12982    | 0.12982    | 0.12982    |   0.0 |  0.12
Other   |            | 0.01433    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715584 ave      715584 max      715584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715584
Ave neighs/atom = 178.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 = 253.426735002087, Press = 0.209920074284319
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -13896.291     -13896.291     -14025.693     -14025.693      250.33803      250.33803      47853.862      47853.862     -440.7057      -440.7057     
     80000  -13899.911     -13899.911     -14030.26      -14030.26       252.16857      252.16857      47876.834      47876.834     -1576.9348     -1576.9348    
Loop time of 104.798 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.111 hours/ns, 9.542 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.62     | 104.62     | 104.62     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030234   | 0.030234   | 0.030234   |   0.0 |  0.03
Output  | 5.859e-05  | 5.859e-05  | 5.859e-05  |   0.0 |  0.00
Modify  | 0.12965    | 0.12965    | 0.12965    |   0.0 |  0.12
Other   |            | 0.01454    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715574 ave      715574 max      715574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715574
Ave neighs/atom = 178.8935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.409124271933, Press = 0.326223650116507
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -13899.911     -13899.911     -14030.26      -14030.26       252.16857      252.16857      47876.834      47876.834     -1576.9348     -1576.9348    
     81000  -13903.457     -13903.457     -14033.058     -14033.058      250.72106      250.72106      47857.653      47857.653     -1375.7699     -1375.7699    
Loop time of 104.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.057 hours/ns, 9.560 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.43     | 104.43     | 104.43     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029845   | 0.029845   | 0.029845   |   0.0 |  0.03
Output  | 6.2617e-05 | 6.2617e-05 | 6.2617e-05 |   0.0 |  0.00
Modify  | 0.12906    | 0.12906    | 0.12906    |   0.0 |  0.12
Other   |            | 0.01482    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714836 ave      714836 max      714836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714836
Ave neighs/atom = 178.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 = 253.405377673484, Press = 0.453396023583719
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -13903.457     -13903.457     -14033.058     -14033.058      250.72106      250.72106      47857.653      47857.653     -1375.7699     -1375.7699    
     82000  -13897.667     -13897.667     -14029.867     -14029.867      255.75047      255.75047      47849.516      47849.516     -703.26199     -703.26199    
Loop time of 104.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.105 hours/ns, 9.544 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.6      | 104.6      | 104.6      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03013    | 0.03013    | 0.03013    |   0.0 |  0.03
Output  | 5.326e-05  | 5.326e-05  | 5.326e-05  |   0.0 |  0.00
Modify  | 0.12974    | 0.12974    | 0.12974    |   0.0 |  0.12
Other   |            | 0.01431    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714550 ave      714550 max      714550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714550
Ave neighs/atom = 178.6375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.382560301603, Press = 0.499511773908159
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -13897.667     -13897.667     -14029.867     -14029.867      255.75047      255.75047      47849.516      47849.516     -703.26199     -703.26199    
     83000  -13900.827     -13900.827     -14029.797     -14029.797      249.49987      249.49987      47827.645      47827.645     -176.23612     -176.23612    
Loop time of 104.769 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.102 hours/ns, 9.545 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.59     | 104.59     | 104.59     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02983    | 0.02983    | 0.02983    |   0.0 |  0.03
Output  | 5.3521e-05 | 5.3521e-05 | 5.3521e-05 |   0.0 |  0.00
Modify  | 0.12956    | 0.12956    | 0.12956    |   0.0 |  0.12
Other   |            | 0.01448    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715038 ave      715038 max      715038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715038
Ave neighs/atom = 178.7595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.380213063986, Press = 0.307592348696684
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -13900.827     -13900.827     -14029.797     -14029.797      249.49987      249.49987      47827.645      47827.645     -176.23612     -176.23612    
     84000  -13901.11      -13901.11      -14029.432     -14029.432      248.24808      248.24808      47821.597      47821.597      64.993868      64.993868    
Loop time of 104.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.089 hours/ns, 9.549 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.55     | 104.55     | 104.55     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029742   | 0.029742   | 0.029742   |   0.0 |  0.03
Output  | 5.3401e-05 | 5.3401e-05 | 5.3401e-05 |   0.0 |  0.00
Modify  | 0.12921    | 0.12921    | 0.12921    |   0.0 |  0.12
Other   |            | 0.01432    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715464 ave      715464 max      715464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715464
Ave neighs/atom = 178.866
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.374776703882, Press = 0.236412321958149
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -13901.11      -13901.11      -14029.432     -14029.432      248.24808      248.24808      47821.597      47821.597      64.993868      64.993868    
     85000  -13895.812     -13895.812     -14028.884     -14028.884      257.4356       257.4356       47832.407      47832.407     -34.595743     -34.595743    
Loop time of 104.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.147 hours/ns, 9.530 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.76     | 104.76     | 104.76     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029507   | 0.029507   | 0.029507   |   0.0 |  0.03
Output  | 5.1867e-05 | 5.1867e-05 | 5.1867e-05 |   0.0 |  0.00
Modify  | 0.12879    | 0.12879    | 0.12879    |   0.0 |  0.12
Other   |            | 0.01369    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715448 ave      715448 max      715448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715448
Ave neighs/atom = 178.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 = 253.392069148738, Press = 0.227946162685887
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -13895.812     -13895.812     -14028.884     -14028.884      257.4356       257.4356       47832.407      47832.407     -34.595743     -34.595743    
     86000  -13899.505     -13899.505     -14029.789     -14029.789      252.04312      252.04312      47798.427      47798.427      759.5231       759.5231     
Loop time of 104.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.066 hours/ns, 9.557 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.46     | 104.46     | 104.46     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029911   | 0.029911   | 0.029911   |   0.0 |  0.03
Output  | 5.4793e-05 | 5.4793e-05 | 5.4793e-05 |   0.0 |  0.00
Modify  | 0.12996    | 0.12996    | 0.12996    |   0.0 |  0.12
Other   |            | 0.01441    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715290 ave      715290 max      715290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715290
Ave neighs/atom = 178.8225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.384296165162, Press = 0.873928807038671
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -13899.505     -13899.505     -14029.789     -14029.789      252.04312      252.04312      47798.427      47798.427      759.5231       759.5231     
     87000  -13899.337     -13899.337     -14030.209     -14030.209      253.17974      253.17974      47781.624      47781.624      1198.3673      1198.3673    
Loop time of 104.901 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.139 hours/ns, 9.533 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.73     | 104.73     | 104.73     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029503   | 0.029503   | 0.029503   |   0.0 |  0.03
Output  | 5.1016e-05 | 5.1016e-05 | 5.1016e-05 |   0.0 |  0.00
Modify  | 0.12895    | 0.12895    | 0.12895    |   0.0 |  0.12
Other   |            | 0.01349    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715572 ave      715572 max      715572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715572
Ave neighs/atom = 178.893
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.398401229815, Press = 0.545287756833146
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -13899.337     -13899.337     -14030.209     -14030.209      253.17974      253.17974      47781.624      47781.624      1198.3673      1198.3673    
     88000  -13895.509     -13895.509     -14026.674     -14026.674      253.749        253.749        47793.764      47793.764      1241.0984      1241.0984    
Loop time of 104.886 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.135 hours/ns, 9.534 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.71     | 104.71     | 104.71     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029741   | 0.029741   | 0.029741   |   0.0 |  0.03
Output  | 5.6927e-05 | 5.6927e-05 | 5.6927e-05 |   0.0 |  0.00
Modify  | 0.12926    | 0.12926    | 0.12926    |   0.0 |  0.12
Other   |            | 0.0136     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715762 ave      715762 max      715762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715762
Ave neighs/atom = 178.9405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.404346951737, Press = 0.205400510697472
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -13895.509     -13895.509     -14026.674     -14026.674      253.749        253.749        47793.764      47793.764      1241.0984      1241.0984    
     89000  -13897.096     -13897.096     -14030.612     -14030.612      258.2955       258.2955       47804.467      47804.467      520.2477       520.2477     
Loop time of 104.91 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.142 hours/ns, 9.532 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.74     | 104.74     | 104.74     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029916   | 0.029916   | 0.029916   |   0.0 |  0.03
Output  | 5.4201e-05 | 5.4201e-05 | 5.4201e-05 |   0.0 |  0.00
Modify  | 0.12861    | 0.12861    | 0.12861    |   0.0 |  0.12
Other   |            | 0.01503    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715876 ave      715876 max      715876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715876
Ave neighs/atom = 178.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.40259523389, Press = 0.00338035397390305
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -13897.096     -13897.096     -14030.612     -14030.612      258.2955       258.2955       47804.467      47804.467      520.2477       520.2477     
     90000  -13898.141     -13898.141     -14029.28      -14029.28       253.69594      253.69594      47805.131      47805.131      626.07967      626.07967    
Loop time of 104.888 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.136 hours/ns, 9.534 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.71     | 104.71     | 104.71     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030073   | 0.030073   | 0.030073   |   0.0 |  0.03
Output  | 5.9472e-05 | 5.9472e-05 | 5.9472e-05 |   0.0 |  0.00
Modify  | 0.12901    | 0.12901    | 0.12901    |   0.0 |  0.12
Other   |            | 0.01477    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715574 ave      715574 max      715574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715574
Ave neighs/atom = 178.8935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.417048879448, Press = -0.0505499166390063
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -13898.141     -13898.141     -14029.28      -14029.28       253.69594      253.69594      47805.131      47805.131      626.07967      626.07967    
     91000  -13900.942     -13900.942     -14029.233     -14029.233      248.18774      248.18774      47763.283      47763.283      1746.5755      1746.5755    
Loop time of 104.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.129 hours/ns, 9.536 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.69     | 104.69     | 104.69     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029812   | 0.029812   | 0.029812   |   0.0 |  0.03
Output  | 0.00010947 | 0.00010947 | 0.00010947 |   0.0 |  0.00
Modify  | 0.12909    | 0.12909    | 0.12909    |   0.0 |  0.12
Other   |            | 0.01463    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715770 ave      715770 max      715770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715770
Ave neighs/atom = 178.9425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.405521827904, Press = -0.235768811967118
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -13900.942     -13900.942     -14029.233     -14029.233      248.18774      248.18774      47763.283      47763.283      1746.5755      1746.5755    
     92000  -13896.456     -13896.456     -14028.396     -14028.396      255.24826      255.24826      47802.067      47802.067      770.71658      770.71658    
Loop time of 104.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.143 hours/ns, 9.532 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.74     | 104.74     | 104.74     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0301     | 0.0301     | 0.0301     |   0.0 |  0.03
Output  | 5.1817e-05 | 5.1817e-05 | 5.1817e-05 |   0.0 |  0.00
Modify  | 0.12867    | 0.12867    | 0.12867    |   0.0 |  0.12
Other   |            | 0.01459    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716354 ave      716354 max      716354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716354
Ave neighs/atom = 179.0885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.406918391175, Press = -0.686301198109106
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -13896.456     -13896.456     -14028.396     -14028.396      255.24826      255.24826      47802.067      47802.067      770.71658      770.71658    
     93000  -13897.633     -13897.633     -14029.171     -14029.171      254.46948      254.46948      47846.56       47846.56      -552.12103     -552.12103    
Loop time of 104.837 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.121 hours/ns, 9.539 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.66     | 104.66     | 104.66     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029925   | 0.029925   | 0.029925   |   0.0 |  0.03
Output  | 5.1907e-05 | 5.1907e-05 | 5.1907e-05 |   0.0 |  0.00
Modify  | 0.12899    | 0.12899    | 0.12899    |   0.0 |  0.12
Other   |            | 0.01407    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716046 ave      716046 max      716046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716046
Ave neighs/atom = 179.0115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.397028628531, Press = -0.371921561338509
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -13897.633     -13897.633     -14029.171     -14029.171      254.46948      254.46948      47846.56       47846.56      -552.12103     -552.12103    
     94000  -13898.804     -13898.804     -14029.859     -14029.859      253.53565      253.53565      47856.822      47856.822     -970.43358     -970.43358    
Loop time of 104.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.166 hours/ns, 9.524 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.82     | 104.82     | 104.82     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029674   | 0.029674   | 0.029674   |   0.0 |  0.03
Output  | 0.00012562 | 0.00012562 | 0.00012562 |   0.0 |  0.00
Modify  | 0.12835    | 0.12835    | 0.12835    |   0.0 |  0.12
Other   |            | 0.01459    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715404 ave      715404 max      715404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715404
Ave neighs/atom = 178.851
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.395483064549, Press = -0.209415947296804
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -13898.804     -13898.804     -14029.859     -14029.859      253.53565      253.53565      47856.822      47856.822     -970.43358     -970.43358    
     95000  -13897.431     -13897.431     -14027.071     -14027.071      250.79805      250.79805      47874.083      47874.083     -1136.1965     -1136.1965    
Loop time of 105.026 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.174 hours/ns, 9.521 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.85     | 104.85     | 104.85     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029848   | 0.029848   | 0.029848   |   0.0 |  0.03
Output  | 5.8329e-05 | 5.8329e-05 | 5.8329e-05 |   0.0 |  0.00
Modify  | 0.12932    | 0.12932    | 0.12932    |   0.0 |  0.12
Other   |            | 0.01467    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714946 ave      714946 max      714946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714946
Ave neighs/atom = 178.7365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.386303867914, Press = -0.156972899645098
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -13897.431     -13897.431     -14027.071     -14027.071      250.79805      250.79805      47874.083      47874.083     -1136.1965     -1136.1965    
     96000  -13900.585     -13900.585     -14029.143     -14029.143      248.70475      248.70475      47863.596      47863.596     -1073.7606     -1073.7606    
Loop time of 105.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.290 hours/ns, 9.484 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.27     | 105.27     | 105.27     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029893   | 0.029893   | 0.029893   |   0.0 |  0.03
Output  | 6.0614e-05 | 6.0614e-05 | 6.0614e-05 |   0.0 |  0.00
Modify  | 0.13037    | 0.13037    | 0.13037    |   0.0 |  0.12
Other   |            | 0.01379    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714912 ave      714912 max      714912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714912
Ave neighs/atom = 178.728
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.375849627855, Press = 0.0410797148422384
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -13900.585     -13900.585     -14029.143     -14029.143      248.70475      248.70475      47863.596      47863.596     -1073.7606     -1073.7606    
     97000  -13894.987     -13894.987     -14027.268     -14027.268      255.90652      255.90652      47861.422      47861.422     -753.45972     -753.45972    
Loop time of 105.289 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.247 hours/ns, 9.498 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.12     | 105.12     | 105.12     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029719   | 0.029719   | 0.029719   |   0.0 |  0.03
Output  | 5.7888e-05 | 5.7888e-05 | 5.7888e-05 |   0.0 |  0.00
Modify  | 0.12928    | 0.12928    | 0.12928    |   0.0 |  0.12
Other   |            | 0.01376    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       714764 ave      714764 max      714764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 714764
Ave neighs/atom = 178.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.370897492237, Press = 0.235954756072144
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -13894.987     -13894.987     -14027.268     -14027.268      255.90652      255.90652      47861.422      47861.422     -753.45972     -753.45972    
     98000  -13897.278     -13897.278     -14027.853     -14027.853      252.60637      252.60637      47845.465      47845.465     -407.03444     -407.03444    
Loop time of 105.222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.228 hours/ns, 9.504 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.05     | 105.05     | 105.05     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029764   | 0.029764   | 0.029764   |   0.0 |  0.03
Output  | 6.0514e-05 | 6.0514e-05 | 6.0514e-05 |   0.0 |  0.00
Modify  | 0.12971    | 0.12971    | 0.12971    |   0.0 |  0.12
Other   |            | 0.0138     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715058 ave      715058 max      715058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715058
Ave neighs/atom = 178.7645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.374831477463, Press = 0.153414573518287
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -13897.278     -13897.278     -14027.853     -14027.853      252.60637      252.60637      47845.465      47845.465     -407.03444     -407.03444    
     99000  -13899.588     -13899.588     -14029.682     -14029.682      251.67594      251.67594      47837.201      47837.201     -381.28465     -381.28465    
Loop time of 105.308 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.252 hours/ns, 9.496 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.13     | 105.13     | 105.13     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0298     | 0.0298     | 0.0298     |   0.0 |  0.03
Output  | 6.2908e-05 | 6.2908e-05 | 6.2908e-05 |   0.0 |  0.00
Modify  | 0.12977    | 0.12977    | 0.12977    |   0.0 |  0.12
Other   |            | 0.01379    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715100 ave      715100 max      715100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715100
Ave neighs/atom = 178.775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.392463675693, Press = 0.356689094407446
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -13899.588     -13899.588     -14029.682     -14029.682      251.67594      251.67594      47837.201      47837.201     -381.28465     -381.28465    
    100000  -13893.863     -13893.863     -14026.811     -14026.811      257.19596      257.19596      47829.411      47829.411      232.88692      232.88692    
Loop time of 105.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.289 hours/ns, 9.484 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.27     | 105.27     | 105.27     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029948   | 0.029948   | 0.029948   |   0.0 |  0.03
Output  | 5.2238e-05 | 5.2238e-05 | 5.2238e-05 |   0.0 |  0.00
Modify  | 0.12983    | 0.12983    | 0.12983    |   0.0 |  0.12
Other   |            | 0.01377    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715290 ave      715290 max      715290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715290
Ave neighs/atom = 178.8225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.396932577804, Press = 0.869493039821488
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -13893.863     -13893.863     -14026.811     -14026.811      257.19596      257.19596      47829.411      47829.411      232.88692      232.88692    
    101000  -13896.869     -13896.869     -14028.65      -14028.65       254.94036      254.94036      47814.27       47814.27       446.01201      446.01201    
Loop time of 105.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.255 hours/ns, 9.495 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.15     | 105.15     | 105.15     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029843   | 0.029843   | 0.029843   |   0.0 |  0.03
Output  | 7.3318e-05 | 7.3318e-05 | 7.3318e-05 |   0.0 |  0.00
Modify  | 0.12858    | 0.12858    | 0.12858    |   0.0 |  0.12
Other   |            | 0.0137     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715624 ave      715624 max      715624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715624
Ave neighs/atom = 178.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 = 253.386505862242, Press = 0.267253580224441
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -13896.869     -13896.869     -14028.65      -14028.65       254.94036      254.94036      47814.27       47814.27       446.01201      446.01201    
    102000  -13901.508     -13901.508     -14029.582     -14029.582      247.76883      247.76883      47793.793      47793.793      824.91987      824.91987    
Loop time of 105.138 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.205 hours/ns, 9.511 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.97     | 104.97     | 104.97     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029786   | 0.029786   | 0.029786   |   0.0 |  0.03
Output  | 6.6756e-05 | 6.6756e-05 | 6.6756e-05 |   0.0 |  0.00
Modify  | 0.12776    | 0.12776    | 0.12776    |   0.0 |  0.12
Other   |            | 0.01367    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715738 ave      715738 max      715738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715738
Ave neighs/atom = 178.9345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.376925081353, Press = 0.0661997040030947
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -13901.508     -13901.508     -14029.582     -14029.582      247.76883      247.76883      47793.793      47793.793      824.91987      824.91987    
    103000  -13898.003     -13898.003     -14028.018     -14028.018      251.52318      251.52318      47781.961      47781.961      1348.4017      1348.4017    
Loop time of 105.305 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.251 hours/ns, 9.496 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.13     | 105.13     | 105.13     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029764   | 0.029764   | 0.029764   |   0.0 |  0.03
Output  | 4.9823e-05 | 4.9823e-05 | 4.9823e-05 |   0.0 |  0.00
Modify  | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.12
Other   |            | 0.01366    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715850 ave      715850 max      715850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715850
Ave neighs/atom = 178.9625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.372201395996, Press = -0.103356265797403
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -13898.003     -13898.003     -14028.018     -14028.018      251.52318      251.52318      47781.961      47781.961      1348.4017      1348.4017    
    104000  -13899.157     -13899.157     -14030.753     -14030.753      254.58059      254.58059      47787.966      47787.966      958.53973      958.53973    
Loop time of 104.73 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.092 hours/ns, 9.548 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.56     | 104.56     | 104.56     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029805   | 0.029805   | 0.029805   |   0.0 |  0.03
Output  | 5.7278e-05 | 5.7278e-05 | 5.7278e-05 |   0.0 |  0.00
Modify  | 0.12779    | 0.12779    | 0.12779    |   0.0 |  0.12
Other   |            | 0.01368    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       716180 ave      716180 max      716180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 716180
Ave neighs/atom = 179.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 = 253.370387724935, Press = -0.410093684103428
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -13899.157     -13899.157     -14030.753     -14030.753      254.58059      254.58059      47787.966      47787.966      958.53973      958.53973    
    105000  -13893.098     -13893.098     -14025.724     -14025.724      256.57522      256.57522      47831.058      47831.058      413.28307      413.28307    
Loop time of 104.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.158 hours/ns, 9.527 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.8      | 104.8      | 104.8      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029744   | 0.029744   | 0.029744   |   0.0 |  0.03
Output  | 6.5353e-05 | 6.5353e-05 | 6.5353e-05 |   0.0 |  0.00
Modify  | 0.1279     | 0.1279     | 0.1279     |   0.0 |  0.12
Other   |            | 0.01364    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715630 ave      715630 max      715630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715630
Ave neighs/atom = 178.9075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.379877779447, Press = -0.393364861792957
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -13893.098     -13893.098     -14025.724     -14025.724      256.57522      256.57522      47831.058      47831.058      413.28307      413.28307    
    106000  -13898.124     -13898.124     -14028.51      -14028.51       252.24178      252.24178      47825.289      47825.289      120.45911      120.45911    
Loop time of 104.946 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.152 hours/ns, 9.529 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.77     | 104.77     | 104.77     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029643   | 0.029643   | 0.029643   |   0.0 |  0.03
Output  | 5.7619e-05 | 5.7619e-05 | 5.7619e-05 |   0.0 |  0.00
Modify  | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.12
Other   |            | 0.01367    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715462 ave      715462 max      715462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715462
Ave neighs/atom = 178.8655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.383031504397, Press = -0.184108310860416
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -13898.124     -13898.124     -14028.51      -14028.51       252.24178      252.24178      47825.289      47825.289      120.45911      120.45911    
    107000  -13901.718     -13901.718     -14029.392     -14029.392      246.99506      246.99506      47828.573      47828.573     -126.16129     -126.16129    
Loop time of 105.333 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.259 hours/ns, 9.494 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.16     | 105.16     | 105.16     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029787   | 0.029787   | 0.029787   |   0.0 |  0.03
Output  | 5.3611e-05 | 5.3611e-05 | 5.3611e-05 |   0.0 |  0.00
Modify  | 0.12756    | 0.12756    | 0.12756    |   0.0 |  0.12
Other   |            | 0.01366    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715636 ave      715636 max      715636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715636
Ave neighs/atom = 178.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 = 253.380040685488, Press = -0.19930329826769
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -13901.718     -13901.718     -14029.392     -14029.392      246.99506      246.99506      47828.573      47828.573     -126.16129     -126.16129    
    108000  -13897.074     -13897.074     -14028.663     -14028.663      254.56918      254.56918      47838.417      47838.417     -232.2432      -232.2432     
Loop time of 105.019 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.172 hours/ns, 9.522 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.85     | 104.85     | 104.85     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029669   | 0.029669   | 0.029669   |   0.0 |  0.03
Output  | 5.6506e-05 | 5.6506e-05 | 5.6506e-05 |   0.0 |  0.00
Modify  | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.12
Other   |            | 0.01359    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715712 ave      715712 max      715712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715712
Ave neighs/atom = 178.928
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.358046117523, Press = -0.0464497315443207
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -13897.074     -13897.074     -14028.663     -14028.663      254.56918      254.56918      47838.417      47838.417     -232.2432      -232.2432     
    109000  -13900.1       -13900.1       -14029.782     -14029.782      250.87926      250.87926      47800.925      47800.925      653.72311      653.72311    
Loop time of 105.079 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.189 hours/ns, 9.517 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.91     | 104.91     | 104.91     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029768   | 0.029768   | 0.029768   |   0.0 |  0.03
Output  | 5.9231e-05 | 5.9231e-05 | 5.9231e-05 |   0.0 |  0.00
Modify  | 0.12785    | 0.12785    | 0.12785    |   0.0 |  0.12
Other   |            | 0.01366    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715272 ave      715272 max      715272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715272
Ave neighs/atom = 178.818
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.351242410762, Press = -0.133604183637831
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -13900.1       -13900.1       -14029.782     -14029.782      250.87926      250.87926      47800.925      47800.925      653.72311      653.72311    
    110000  -13896.895     -13896.895     -14030.382     -14030.382      258.24032      258.24032      47821.313      47821.313      109.91973      109.91973    
Loop time of 105.044 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.179 hours/ns, 9.520 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.87     | 104.87     | 104.87     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029787   | 0.029787   | 0.029787   |   0.0 |  0.03
Output  | 5.8791e-05 | 5.8791e-05 | 5.8791e-05 |   0.0 |  0.00
Modify  | 0.12791    | 0.12791    | 0.12791    |   0.0 |  0.12
Other   |            | 0.01365    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715600 ave      715600 max      715600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715600
Ave neighs/atom = 178.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 = 253.350604372184, Press = -0.387965181533724
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -13896.895     -13896.895     -14030.382     -14030.382      258.24032      258.24032      47821.313      47821.313      109.91973      109.91973    
    111000  -13900.567     -13900.567     -14029.68      -14029.68       249.77802      249.77802      47820.954      47820.954      19.107811      19.107811    
Loop time of 105.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.168 hours/ns, 9.523 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.83     | 104.83     | 104.83     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02972    | 0.02972    | 0.02972    |   0.0 |  0.03
Output  | 5.6686e-05 | 5.6686e-05 | 5.6686e-05 |   0.0 |  0.00
Modify  | 0.1279     | 0.1279     | 0.1279     |   0.0 |  0.12
Other   |            | 0.01364    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715410 ave      715410 max      715410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715410
Ave neighs/atom = 178.8525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.347010789186, Press = -0.284879883602349
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -13900.567     -13900.567     -14029.68      -14029.68       249.77802      249.77802      47820.954      47820.954      19.107811      19.107811    
    112000  -13893.779     -13893.779     -14027.099     -14027.099      257.91545      257.91545      47836.658      47836.658     -7.162755      -7.162755     
Loop time of 105.031 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.175 hours/ns, 9.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    | 104.86     | 104.86     | 104.86     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029707   | 0.029707   | 0.029707   |   0.0 |  0.03
Output  | 5.331e-05  | 5.331e-05  | 5.331e-05  |   0.0 |  0.00
Modify  | 0.12776    | 0.12776    | 0.12776    |   0.0 |  0.12
Other   |            | 0.01362    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715814 ave      715814 max      715814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715814
Ave neighs/atom = 178.9535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.348960606721, Press = -0.527837945568437
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -13893.779     -13893.779     -14027.099     -14027.099      257.91545      257.91545      47836.658      47836.658     -7.162755      -7.162755     
    113000  -13899.6       -13899.6       -14027.45      -14027.45       247.33393      247.33393      47843.688      47843.688     -391.16524     -391.16524    
Loop time of 105.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.228 hours/ns, 9.504 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.05     | 105.05     | 105.05     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029675   | 0.029675   | 0.029675   |   0.0 |  0.03
Output  | 5.4092e-05 | 5.4092e-05 | 5.4092e-05 |   0.0 |  0.00
Modify  | 0.12792    | 0.12792    | 0.12792    |   0.0 |  0.12
Other   |            | 0.01363    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715642 ave      715642 max      715642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715642
Ave neighs/atom = 178.9105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.349863021646, Press = -0.427458271949512
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -13899.6       -13899.6       -14027.45      -14027.45       247.33393      247.33393      47843.688      47843.688     -391.16524     -391.16524    
    114000  -13898.161     -13898.161     -14028.252     -14028.252      251.66938      251.66938      47845.643      47845.643     -514.17454     -514.17454    
Loop time of 105.106 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.196 hours/ns, 9.514 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.94     | 104.94     | 104.94     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029667   | 0.029667   | 0.029667   |   0.0 |  0.03
Output  | 6.1205e-05 | 6.1205e-05 | 6.1205e-05 |   0.0 |  0.00
Modify  | 0.12725    | 0.12725    | 0.12725    |   0.0 |  0.12
Other   |            | 0.01352    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 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:       715474 ave      715474 max      715474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715474
Ave neighs/atom = 178.8685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
47827.1742073919

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0