# 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.521391749382019*${_u_distance}
variable latticeconst_converted equal 3.521391749382019*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174938202
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  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 (35.213917 35.213917 35.213917)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ni

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

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


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9614516893 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17658.806     -17658.806     -17800         -17800          273.15         273.15         43665.961      43665.961      3453.8109      3453.8109    
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3467     -1595.3467    
Loop time of 448.742 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.651 hours/ns, 2.228 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 447.79     | 447.79     | 447.79     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14941    | 0.14941    | 0.14941    |   0.0 |  0.03
Output  | 0.00024509 | 0.00024509 | 0.00024509 |   0.0 |  0.00
Modify  | 0.70568    | 0.70568    | 0.70568    |   0.0 |  0.16
Other   |            | 0.1002     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       344000 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3467     -1595.3467    
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26218      267.26218      44092.267      44092.267      513.4551       513.4551     
Loop time of 479.787 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.274 hours/ns, 2.084 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.82     | 478.82     | 478.82     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15155    | 0.15155    | 0.15155    |   0.0 |  0.03
Output  | 0.0002297  | 0.0002297  | 0.0002297  |   0.0 |  0.00
Modify  | 0.71635    | 0.71635    | 0.71635    |   0.0 |  0.15
Other   |            | 0.1016     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357140 ave      357140 max      357140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357140
Ave neighs/atom = 89.285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26218      267.26218      44092.267      44092.267      513.4551       513.4551     
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78533      359.78533    
Loop time of 475.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.996 hours/ns, 2.104 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 474.23     | 474.23     | 474.23     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14944    | 0.14944    | 0.14944    |   0.0 |  0.03
Output  | 0.00022968 | 0.00022968 | 0.00022968 |   0.0 |  0.00
Modify  | 0.70593    | 0.70593    | 0.70593    |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359132 ave      359132 max      359132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359132
Ave neighs/atom = 89.783
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78533      359.78533    
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.665389     -41.665389    
Loop time of 479.078 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.077 hours/ns, 2.087 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.1      | 478.1      | 478.1      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15171    | 0.15171    | 0.15171    |   0.0 |  0.03
Output  | 0.00022605 | 0.00022605 | 0.00022605 |   0.0 |  0.00
Modify  | 0.72273    | 0.72273    | 0.72273    |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358894 ave      358894 max      358894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358894
Ave neighs/atom = 89.7235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.665389     -41.665389    
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97832     -295.97832    
Loop time of 477.218 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.560 hours/ns, 2.095 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 476.25     | 476.25     | 476.25     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15002    | 0.15002    | 0.15002    |   0.0 |  0.03
Output  | 0.00018853 | 0.00018853 | 0.00018853 |   0.0 |  0.00
Modify  | 0.71893    | 0.71893    | 0.71893    |   0.0 |  0.15
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358444 ave      358444 max      358444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358444
Ave neighs/atom = 89.611
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 270.611136082637, Press = -333.668711516833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97832     -295.97832    
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4794      2027.4794    
Loop time of 478.87 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.019 hours/ns, 2.088 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.87     | 477.87     | 477.87     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15079    | 0.15079    | 0.15079    |   0.0 |  0.03
Output  | 0.00023467 | 0.00023467 | 0.00023467 |   0.0 |  0.00
Modify  | 0.74838    | 0.74838    | 0.74838    |   0.0 |  0.16
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357794 ave      357794 max      357794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357794
Ave neighs/atom = 89.4485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.788199497571, Press = 6.19618061821112
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4794      2027.4794    
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9727     -2174.9727    
Loop time of 483.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.412 hours/ns, 2.067 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.87     | 482.87     | 482.87     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15185    | 0.15185    | 0.15185    |   0.0 |  0.03
Output  | 0.00018977 | 0.00018977 | 0.00018977 |   0.0 |  0.00
Modify  | 0.75613    | 0.75613    | 0.75613    |   0.0 |  0.16
Other   |            | 0.1029     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359788 ave      359788 max      359788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359788
Ave neighs/atom = 89.947
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.017667486587, Press = 7.42250588419641
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9727     -2174.9727    
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30591     -104.30591    
Loop time of 484.489 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.580 hours/ns, 2.064 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.46     | 483.46     | 483.46     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1541     | 0.1541     | 0.1541     |   0.0 |  0.03
Output  | 0.00029077 | 0.00029077 | 0.00029077 |   0.0 |  0.00
Modify  | 0.76646    | 0.76646    | 0.76646    |   0.0 |  0.16
Other   |            | 0.1033     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357162 ave      357162 max      357162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357162
Ave neighs/atom = 89.2905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.964957538257, Press = -22.1650936816845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30591     -104.30591    
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80966      271.80966      44081.577      44081.577      584.3534       584.3534     
Loop time of 482.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.162 hours/ns, 2.070 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.97     | 481.97     | 481.97     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15187    | 0.15187    | 0.15187    |   0.0 |  0.03
Output  | 0.00018964 | 0.00018964 | 0.00018964 |   0.0 |  0.00
Modify  | 0.7548     | 0.7548     | 0.7548     |   0.0 |  0.16
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358060 ave      358060 max      358060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358060
Ave neighs/atom = 89.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.602524391551, Press = 1.69507694837895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80966      271.80966      44081.577      44081.577      584.3534       584.3534     
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18343      278.18343      44139.015      44139.015     -1088.1278     -1088.1278    
Loop time of 484.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.613 hours/ns, 2.064 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.59     | 483.59     | 483.59     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1526     | 0.1526     | 0.1526     |   0.0 |  0.03
Output  | 0.00024543 | 0.00024543 | 0.00024543 |   0.0 |  0.00
Modify  | 0.76431    | 0.76431    | 0.76431    |   0.0 |  0.16
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358362 ave      358362 max      358362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358362
Ave neighs/atom = 89.5905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.92079355106, Press = -2.82757383035038
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18343      278.18343      44139.015      44139.015     -1088.1278     -1088.1278    
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17783      265.17783      44083.794      44083.794      857.98174      857.98174    
Loop time of 488.375 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.660 hours/ns, 2.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 487.35     | 487.35     | 487.35     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15339    | 0.15339    | 0.15339    |   0.0 |  0.03
Output  | 0.00024075 | 0.00024075 | 0.00024075 |   0.0 |  0.00
Modify  | 0.76857    | 0.76857    | 0.76857    |   0.0 |  0.16
Other   |            | 0.1026     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358390 ave      358390 max      358390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358390
Ave neighs/atom = 89.5975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.111359952268, Press = -5.06886858779674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17783      265.17783      44083.794      44083.794      857.98174      857.98174    
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93848      272.93848      44077.693      44077.693      626.51934      626.51934    
Loop time of 483.827 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.396 hours/ns, 2.067 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.81     | 482.81     | 482.81     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1523     | 0.1523     | 0.1523     |   0.0 |  0.03
Output  | 0.00019116 | 0.00019116 | 0.00019116 |   0.0 |  0.00
Modify  | 0.7624     | 0.7624     | 0.7624     |   0.0 |  0.16
Other   |            | 0.1028     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359146 ave      359146 max      359146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359146
Ave neighs/atom = 89.7865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.170095479048, Press = 6.06933499379319
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93848      272.93848      44077.693      44077.693      626.51934      626.51934    
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69302      277.69302      44168.987      44168.987     -2879.595      -2879.595     
Loop time of 484.552 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.598 hours/ns, 2.064 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.54     | 483.54     | 483.54     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15356    | 0.15356    | 0.15356    |   0.0 |  0.03
Output  | 0.00018861 | 0.00018861 | 0.00018861 |   0.0 |  0.00
Modify  | 0.76012    | 0.76012    | 0.76012    |   0.0 |  0.16
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358348 ave      358348 max      358348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358348
Ave neighs/atom = 89.587
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.041610985939, Press = -4.17417116129432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69302      277.69302      44168.987      44168.987     -2879.595      -2879.595     
     14000  -17520.899     -17520.899     -17661.44      -17661.44       271.88542      271.88542      44067.128      44067.128      971.71875      971.71875    
Loop time of 477.411 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.614 hours/ns, 2.095 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 476.41     | 476.41     | 476.41     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15062    | 0.15062    | 0.15062    |   0.0 |  0.03
Output  | 0.00019166 | 0.00019166 | 0.00019166 |   0.0 |  0.00
Modify  | 0.7451     | 0.7451     | 0.7451     |   0.0 |  0.16
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356964 ave      356964 max      356964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356964
Ave neighs/atom = 89.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.838281064646, Press = -4.42953412966229
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17520.899     -17520.899     -17661.44      -17661.44       271.88542      271.88542      44067.128      44067.128      971.71875      971.71875    
     15000  -17517.76      -17517.76      -17657.376     -17657.376      270.09576      270.09576      44096.829      44096.829      151.70501      151.70501    
Loop time of 483.039 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.178 hours/ns, 2.070 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.03     | 482.03     | 482.03     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15227    | 0.15227    | 0.15227    |   0.0 |  0.03
Output  | 0.00019031 | 0.00019031 | 0.00019031 |   0.0 |  0.00
Modify  | 0.75855    | 0.75855    | 0.75855    |   0.0 |  0.16
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358410 ave      358410 max      358410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358410
Ave neighs/atom = 89.6025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824944420892, Press = 1.52598220990441
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17517.76      -17517.76      -17657.376     -17657.376      270.09576      270.09576      44096.829      44096.829      151.70501      151.70501    
     16000  -17513.577     -17513.577     -17658.038     -17658.038      279.46858      279.46858      44126.697      44126.697     -1048.7705     -1048.7705    
Loop time of 475.125 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.979 hours/ns, 2.105 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 474.13     | 474.13     | 474.13     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15046    | 0.15046    | 0.15046    |   0.0 |  0.03
Output  | 0.00024607 | 0.00024607 | 0.00024607 |   0.0 |  0.00
Modify  | 0.73844    | 0.73844    | 0.73844    |   0.0 |  0.16
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358506 ave      358506 max      358506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358506
Ave neighs/atom = 89.6265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.76687942305, Press = -2.13206615593713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17513.577     -17513.577     -17658.038     -17658.038      279.46858      279.46858      44126.697      44126.697     -1048.7705     -1048.7705    
     17000  -17520.529     -17520.529     -17660.334     -17660.334      270.46146      270.46146      44076.679      44076.679      640.4499       640.4499     
Loop time of 476.54 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.372 hours/ns, 2.098 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 475.54     | 475.54     | 475.54     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15036    | 0.15036    | 0.15036    |   0.0 |  0.03
Output  | 0.00023268 | 0.00023268 | 0.00023268 |   0.0 |  0.00
Modify  | 0.74642    | 0.74642    | 0.74642    |   0.0 |  0.16
Other   |            | 0.1031     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357884 ave      357884 max      357884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357884
Ave neighs/atom = 89.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.733532086355, Press = -2.6423725083539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17520.529     -17520.529     -17660.334     -17660.334      270.46146      270.46146      44076.679      44076.679      640.4499       640.4499     
     18000  -17514.9       -17514.9       -17657.54      -17657.54       275.94709      275.94709      44070.39       44070.39       1192.7939      1192.7939    
Loop time of 479.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.255 hours/ns, 2.085 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.71     | 478.71     | 478.71     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15157    | 0.15157    | 0.15157    |   0.0 |  0.03
Output  | 0.0001882  | 0.0001882  | 0.0001882  |   0.0 |  0.00
Modify  | 0.75185    | 0.75185    | 0.75185    |   0.0 |  0.16
Other   |            | 0.1016     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358450 ave      358450 max      358450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358450
Ave neighs/atom = 89.6125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.661365647541, Press = 3.64580729219451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17514.9       -17514.9       -17657.54      -17657.54       275.94709      275.94709      44070.39       44070.39       1192.7939      1192.7939    
     19000  -17518.075     -17518.075     -17658.703     -17658.703      272.05427      272.05427      44151.141      44151.141     -2248.4204     -2248.4204    
Loop time of 479.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.289 hours/ns, 2.084 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.84     | 478.84     | 478.84     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15198    | 0.15198    | 0.15198    |   0.0 |  0.03
Output  | 0.00018953 | 0.00018953 | 0.00018953 |   0.0 |  0.00
Modify  | 0.74695    | 0.74695    | 0.74695    |   0.0 |  0.16
Other   |            | 0.103      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359170 ave      359170 max      359170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359170
Ave neighs/atom = 89.7925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.632028206332, Press = -2.13268786051467
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17518.075     -17518.075     -17658.703     -17658.703      272.05427      272.05427      44151.141      44151.141     -2248.4204     -2248.4204    
     20000  -17513.051     -17513.051     -17654.721     -17654.721      274.06972      274.06972      44075.708      44075.708      1335.5543      1335.5543    
Loop time of 478.464 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.907 hours/ns, 2.090 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.47     | 477.47     | 477.47     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14972    | 0.14972    | 0.14972    |   0.0 |  0.03
Output  | 0.00018988 | 0.00018988 | 0.00018988 |   0.0 |  0.00
Modify  | 0.74195    | 0.74195    | 0.74195    |   0.0 |  0.16
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357060 ave      357060 max      357060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357060
Ave neighs/atom = 89.265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.677965021757, Press = -1.89933619928786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17513.051     -17513.051     -17654.721     -17654.721      274.06972      274.06972      44075.708      44075.708      1335.5543      1335.5543    
     21000  -17517.248     -17517.248     -17660.713     -17660.713      277.54238      277.54238      44102.725      44102.725     -382.17868     -382.17868    
Loop time of 476.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.324 hours/ns, 2.099 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 475.37     | 475.37     | 475.37     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14934    | 0.14934    | 0.14934    |   0.0 |  0.03
Output  | 0.0001874  | 0.0001874  | 0.0001874  |   0.0 |  0.00
Modify  | 0.74389    | 0.74389    | 0.74389    |   0.0 |  0.16
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359576 ave      359576 max      359576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359576
Ave neighs/atom = 89.894
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.698206984113, Press = 1.43348505374376
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17517.248     -17517.248     -17660.713     -17660.713      277.54238      277.54238      44102.725      44102.725     -382.17868     -382.17868    
     22000  -17517.159     -17517.159     -17658.443     -17658.443      273.32295      273.32295      44120.128      44120.128     -920.8647      -920.8647     
Loop time of 481.504 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 133.751 hours/ns, 2.077 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 480.49     | 480.49     | 480.49     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15211    | 0.15211    | 0.15211    |   0.0 |  0.03
Output  | 0.00019288 | 0.00019288 | 0.00019288 |   0.0 |  0.00
Modify  | 0.76124    | 0.76124    | 0.76124    |   0.0 |  0.16
Other   |            | 0.1025     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358040 ave      358040 max      358040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358040
Ave neighs/atom = 89.51
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.724748988174, Press = -1.55870095745223
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17517.159     -17517.159     -17658.443     -17658.443      273.32295      273.32295      44120.128      44120.128     -920.8647      -920.8647     
     23000  -17513.932     -17513.932     -17656.636     -17656.636      276.07052      276.07052      44096.855      44096.855      250.38645      250.38645    
Loop time of 486.845 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.177 ns/day, 135.235 hours/ns, 2.054 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 485.81     | 485.81     | 485.81     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15376    | 0.15376    | 0.15376    |   0.0 |  0.03
Output  | 0.00018832 | 0.00018832 | 0.00018832 |   0.0 |  0.00
Modify  | 0.77373    | 0.77373    | 0.77373    |   0.0 |  0.16
Other   |            | 0.1036     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358072 ave      358072 max      358072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358072
Ave neighs/atom = 89.518
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.755988504647, Press = -0.419662988885376
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17513.932     -17513.932     -17656.636     -17656.636      276.07052      276.07052      44096.855      44096.855      250.38645      250.38645    
     24000  -17519.783     -17519.783     -17659.718     -17659.718      270.7125       270.7125       44099.77       44099.77      -276.23312     -276.23312    
Loop time of 484.299 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.178 ns/day, 134.527 hours/ns, 2.065 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 483.29     | 483.29     | 483.29     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15179    | 0.15179    | 0.15179    |   0.0 |  0.03
Output  | 0.00023342 | 0.00023342 | 0.00023342 |   0.0 |  0.00
Modify  | 0.75602    | 0.75602    | 0.75602    |   0.0 |  0.16
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358780 ave      358780 max      358780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358780
Ave neighs/atom = 89.695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.673135098235, Press = -0.2978093784823
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17519.783     -17519.783     -17659.718     -17659.718      270.7125       270.7125       44099.77       44099.77      -276.23312     -276.23312    
     25000  -17516.095     -17516.095     -17656.418     -17656.418      271.4641       271.4641       44108.199      44108.199     -266.63236     -266.63236    
Loop time of 476.172 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.270 hours/ns, 2.100 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 475.18     | 475.18     | 475.18     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14998    | 0.14998    | 0.14998    |   0.0 |  0.03
Output  | 0.0002321  | 0.0002321  | 0.0002321  |   0.0 |  0.00
Modify  | 0.73804    | 0.73804    | 0.73804    |   0.0 |  0.15
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358354 ave      358354 max      358354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358354
Ave neighs/atom = 89.5885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.665028310632, Press = -0.728885627286727
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17516.095     -17516.095     -17656.418     -17656.418      271.4641       271.4641       44108.199      44108.199     -266.63236     -266.63236    
     26000  -17516.691     -17516.691     -17655.232     -17655.232      268.01711      268.01711      44085.892      44085.892      774.98473      774.98473    
Loop time of 482.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 133.988 hours/ns, 2.073 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.34     | 481.34     | 481.34     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15277    | 0.15277    | 0.15277    |   0.0 |  0.03
Output  | 0.00023435 | 0.00023435 | 0.00023435 |   0.0 |  0.00
Modify  | 0.75682    | 0.75682    | 0.75682    |   0.0 |  0.16
Other   |            | 0.1026     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358546 ave      358546 max      358546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358546
Ave neighs/atom = 89.6365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.634504470538, Press = -1.20399946795337
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17516.691     -17516.691     -17655.232     -17655.232      268.01711      268.01711      44085.892      44085.892      774.98473      774.98473    
     27000  -17516.717     -17516.717     -17658.876     -17658.876      275.01585      275.01585      44099.593      44099.593     -155.71942     -155.71942    
Loop time of 476.892 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.470 hours/ns, 2.097 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 475.89     | 475.89     | 475.89     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15029    | 0.15029    | 0.15029    |   0.0 |  0.03
Output  | 0.00018761 | 0.00018761 | 0.00018761 |   0.0 |  0.00
Modify  | 0.75039    | 0.75039    | 0.75039    |   0.0 |  0.16
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359016 ave      359016 max      359016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359016
Ave neighs/atom = 89.754
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.66366613398, Press = 0.307754015343451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17516.717     -17516.717     -17658.876     -17658.876      275.01585      275.01585      44099.593      44099.593     -155.71942     -155.71942    
     28000  -17514.142     -17514.142     -17655.671     -17655.671      273.79778      273.79778      44133.181      44133.181     -1208.1713     -1208.1713    
Loop time of 482.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 133.959 hours/ns, 2.074 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.24     | 481.24     | 481.24     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15196    | 0.15196    | 0.15196    |   0.0 |  0.03
Output  | 0.0001901  | 0.0001901  | 0.0001901  |   0.0 |  0.00
Modify  | 0.76262    | 0.76262    | 0.76262    |   0.0 |  0.16
Other   |            | 0.1036     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358780 ave      358780 max      358780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358780
Ave neighs/atom = 89.695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.698759745141, Press = -1.97694214216152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17514.142     -17514.142     -17655.671     -17655.671      273.79778      273.79778      44133.181      44133.181     -1208.1713     -1208.1713    
     29000  -17517.648     -17517.648     -17656.697     -17656.697      268.99875      268.99875      44039.849      44039.849      2556.1765      2556.1765    
Loop time of 479.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.146 hours/ns, 2.086 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.31     | 478.31     | 478.31     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14942    | 0.14942    | 0.14942    |   0.0 |  0.03
Output  | 0.00018956 | 0.00018956 | 0.00018956 |   0.0 |  0.00
Modify  | 0.75709    | 0.75709    | 0.75709    |   0.0 |  0.16
Other   |            | 0.1031     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358120 ave      358120 max      358120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358120
Ave neighs/atom = 89.53
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.713007058618, Press = -1.4034321882459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17517.648     -17517.648     -17656.697     -17656.697      268.99875      268.99875      44039.849      44039.849      2556.1765      2556.1765    
     30000  -17516.457     -17516.457     -17656.973     -17656.973      271.83784      271.83784      44113.63       44113.63      -575.00743     -575.00743    
Loop time of 478.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.938 hours/ns, 2.090 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.58     | 477.58     | 477.58     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14606    | 0.14606    | 0.14606    |   0.0 |  0.03
Output  | 0.00018869 | 0.00018869 | 0.00018869 |   0.0 |  0.00
Modify  | 0.74844    | 0.74844    | 0.74844    |   0.0 |  0.16
Other   |            | 0.1024     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359548 ave      359548 max      359548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359548
Ave neighs/atom = 89.887
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.750118191168, Press = 1.55327301201344
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17516.457     -17516.457     -17656.973     -17656.973      271.83784      271.83784      44113.63       44113.63      -575.00743     -575.00743    
     31000  -17515.604     -17515.604     -17656.41      -17656.41       272.39845      272.39845      44112.71       44112.71      -445.4655      -445.4655     
Loop time of 479.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.328 hours/ns, 2.083 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.98     | 478.98     | 478.98     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14811    | 0.14811    | 0.14811    |   0.0 |  0.03
Output  | 0.00018781 | 0.00018781 | 0.00018781 |   0.0 |  0.00
Modify  | 0.75028    | 0.75028    | 0.75028    |   0.0 |  0.16
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358060 ave      358060 max      358060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358060
Ave neighs/atom = 89.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.754979105817, Press = -1.2148888018601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17515.604     -17515.604     -17656.41      -17656.41       272.39845      272.39845      44112.71       44112.71      -445.4655      -445.4655     
     32000  -17517.529     -17517.529     -17658.237     -17658.237      272.20942      272.20942      44083.571      44083.571      507.79814      507.79814    
Loop time of 478.519 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.922 hours/ns, 2.090 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.52     | 477.52     | 477.52     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14714    | 0.14714    | 0.14714    |   0.0 |  0.03
Output  | 0.00019063 | 0.00019063 | 0.00019063 |   0.0 |  0.00
Modify  | 0.74745    | 0.74745    | 0.74745    |   0.0 |  0.16
Other   |            | 0.1024     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358340 ave      358340 max      358340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358340
Ave neighs/atom = 89.585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.785854098745, Press = -0.494674124424525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17517.529     -17517.529     -17658.237     -17658.237      272.20942      272.20942      44083.571      44083.571      507.79814      507.79814    
     33000  -17511.348     -17511.348     -17654.703     -17654.703      277.32907      277.32907      44121.518      44121.518     -608.27849     -608.27849    
Loop time of 478.215 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.837 hours/ns, 2.091 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.23     | 477.23     | 477.23     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14502    | 0.14502    | 0.14502    |   0.0 |  0.03
Output  | 0.00019017 | 0.00019017 | 0.00019017 |   0.0 |  0.00
Modify  | 0.74138    | 0.74138    | 0.74138    |   0.0 |  0.16
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358890 ave      358890 max      358890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358890
Ave neighs/atom = 89.7225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.844580106409, Press = -0.499013143948237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17511.348     -17511.348     -17654.703     -17654.703      277.32907      277.32907      44121.518      44121.518     -608.27849     -608.27849    
     34000  -17519.302     -17519.302     -17657.965     -17657.965      268.25302      268.25302      44089.993      44089.993      329.93642      329.93642    
Loop time of 479.896 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.304 hours/ns, 2.084 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 478.89     | 478.89     | 478.89     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14884    | 0.14884    | 0.14884    |   0.0 |  0.03
Output  | 0.00018853 | 0.00018853 | 0.00018853 |   0.0 |  0.00
Modify  | 0.75263    | 0.75263    | 0.75263    |   0.0 |  0.16
Other   |            | 0.1033     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358560 ave      358560 max      358560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358560
Ave neighs/atom = 89.64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.86010927377, Press = -1.3211349335522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17519.302     -17519.302     -17657.965     -17657.965      268.25302      268.25302      44089.993      44089.993      329.93642      329.93642    
     35000  -17515.085     -17515.085     -17655.94      -17655.94       272.49398      272.49398      44075.991      44075.991      1130.1519      1130.1519    
Loop time of 473.248 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.458 hours/ns, 2.113 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 472.27     | 472.27     | 472.27     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1451     | 0.1451     | 0.1451     |   0.0 |  0.03
Output  | 0.00019407 | 0.00019407 | 0.00019407 |   0.0 |  0.00
Modify  | 0.72818    | 0.72818    | 0.72818    |   0.0 |  0.15
Other   |            | 0.1008     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358388 ave      358388 max      358388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358388
Ave neighs/atom = 89.597
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.840807242753, Press = 0.575725504830871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17515.085     -17515.085     -17655.94      -17655.94       272.49398      272.49398      44075.991      44075.991      1130.1519      1130.1519    
     36000  -17517.294     -17517.294     -17658.014     -17658.014      272.2338       272.2338       44143.331      44143.331     -1828.4257     -1828.4257    
Loop time of 472.26 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.183 hours/ns, 2.117 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.28     | 471.28     | 471.28     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14505    | 0.14505    | 0.14505    |   0.0 |  0.03
Output  | 0.00019048 | 0.00019048 | 0.00019048 |   0.0 |  0.00
Modify  | 0.73221    | 0.73221    | 0.73221    |   0.0 |  0.16
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359246 ave      359246 max      359246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359246
Ave neighs/atom = 89.8115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.788216142202, Press = -0.474878975634343
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17517.294     -17517.294     -17658.014     -17658.014      272.2338       272.2338       44143.331      44143.331     -1828.4257     -1828.4257    
     37000  -17516.964     -17516.964     -17657.829     -17657.829      272.51323      272.51323      44077.313      44077.313      945.53715      945.53715    
Loop time of 470.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.606 hours/ns, 2.127 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 469.2      | 469.2      | 469.2      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14573    | 0.14573    | 0.14573    |   0.0 |  0.03
Output  | 0.00018964 | 0.00018964 | 0.00018964 |   0.0 |  0.00
Modify  | 0.73392    | 0.73392    | 0.73392    |   0.0 |  0.16
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357494 ave      357494 max      357494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357494
Ave neighs/atom = 89.3735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.779582517141, Press = -1.8021446541381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17516.964     -17516.964     -17657.829     -17657.829      272.51323      272.51323      44077.313      44077.313      945.53715      945.53715    
     38000  -17513.243     -17513.243     -17656.008     -17656.008      276.1888       276.1888       44089.381      44089.381      605.94874      605.94874    
Loop time of 469.222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.339 hours/ns, 2.131 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 468.25     | 468.25     | 468.25     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14468    | 0.14468    | 0.14468    |   0.0 |  0.03
Output  | 0.00052696 | 0.00052696 | 0.00052696 |   0.0 |  0.00
Modify  | 0.7233     | 0.7233     | 0.7233     |   0.0 |  0.15
Other   |            | 0.1007     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358368 ave      358368 max      358368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358368
Ave neighs/atom = 89.592
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.77621047762, Press = 0.759995596680089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17513.243     -17513.243     -17656.008     -17656.008      276.1888       276.1888       44089.381      44089.381      605.94874      605.94874    
     39000  -17516.279     -17516.279     -17656.536     -17656.536      271.33666      271.33666      44125.714      44125.714     -942.18679     -942.18679    
Loop time of 480.189 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.386 hours/ns, 2.083 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 479.19     | 479.19     | 479.19     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14736    | 0.14736    | 0.14736    |   0.0 |  0.03
Output  | 0.00018869 | 0.00018869 | 0.00018869 |   0.0 |  0.00
Modify  | 0.74965    | 0.74965    | 0.74965    |   0.0 |  0.16
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358918 ave      358918 max      358918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358918
Ave neighs/atom = 89.7295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.768908814916, Press = -0.781606374835638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17516.279     -17516.279     -17656.536     -17656.536      271.33666      271.33666      44125.714      44125.714     -942.18679     -942.18679    
     40000  -17519.845     -17519.845     -17659.262     -17659.262      269.71079      269.71079      44078.426      44078.426      645.95521      645.95521    
Loop time of 480.261 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.406 hours/ns, 2.082 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 479.26     | 479.26     | 479.26     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14802    | 0.14802    | 0.14802    |   0.0 |  0.03
Output  | 0.00019014 | 0.00019014 | 0.00019014 |   0.0 |  0.00
Modify  | 0.74715    | 0.74715    | 0.74715    |   0.0 |  0.16
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357832 ave      357832 max      357832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357832
Ave neighs/atom = 89.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.778553883366, Press = -0.881474291750019
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17519.845     -17519.845     -17659.262     -17659.262      269.71079      269.71079      44078.426      44078.426      645.95521      645.95521    
     41000  -17514.137     -17514.137     -17654.72      -17654.72       271.96795      271.96795      44094.801      44094.801      502.66988      502.66988    
Loop time of 480.84 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.180 ns/day, 133.567 hours/ns, 2.080 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 479.84     | 479.84     | 479.84     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14758    | 0.14758    | 0.14758    |   0.0 |  0.03
Output  | 0.00023078 | 0.00023078 | 0.00023078 |   0.0 |  0.00
Modify  | 0.75435    | 0.75435    | 0.75435    |   0.0 |  0.16
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358360 ave      358360 max      358360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358360
Ave neighs/atom = 89.59
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.769247636175, Press = 0.346198636426801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17514.137     -17514.137     -17654.72      -17654.72       271.96795      271.96795      44094.801      44094.801      502.66988      502.66988    
     42000  -17522.821     -17522.821     -17659.003     -17659.003      263.45358      263.45358      44116.464      44116.464     -1035.8452     -1035.8452    
Loop time of 477.15 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.542 hours/ns, 2.096 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 476.16     | 476.16     | 476.16     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14695    | 0.14695    | 0.14695    |   0.0 |  0.03
Output  | 0.00019234 | 0.00019234 | 0.00019234 |   0.0 |  0.00
Modify  | 0.74421    | 0.74421    | 0.74421    |   0.0 |  0.16
Other   |            | 0.1016     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358728 ave      358728 max      358728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358728
Ave neighs/atom = 89.682
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.734555979602, Press = -0.735357547314216
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17522.821     -17522.821     -17659.003     -17659.003      263.45358      263.45358      44116.464      44116.464     -1035.8452     -1035.8452    
     43000  -17514.499     -17514.499     -17654.887     -17654.887      271.59064      271.59064      44061.772      44061.772      1777.4092      1777.4092    
Loop time of 476.459 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.350 hours/ns, 2.099 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 475.47     | 475.47     | 475.47     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14588    | 0.14588    | 0.14588    |   0.0 |  0.03
Output  | 0.00024024 | 0.00024024 | 0.00024024 |   0.0 |  0.00
Modify  | 0.73903    | 0.73903    | 0.73903    |   0.0 |  0.16
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358066 ave      358066 max      358066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358066
Ave neighs/atom = 89.5165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.731062342191, Press = -1.27802720797405
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17514.499     -17514.499     -17654.887     -17654.887      271.59064      271.59064      44061.772      44061.772      1777.4092      1777.4092    
     44000  -17515.998     -17515.998     -17656.341     -17656.341      271.50318      271.50318      44098.819      44098.819      123.00371      123.00371    
Loop time of 483.421 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.179 ns/day, 134.284 hours/ns, 2.069 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 482.41     | 482.41     | 482.41     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14891    | 0.14891    | 0.14891    |   0.0 |  0.03
Output  | 0.0001865  | 0.0001865  | 0.0001865  |   0.0 |  0.00
Modify  | 0.75892    | 0.75892    | 0.75892    |   0.0 |  0.16
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359386 ave      359386 max      359386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359386
Ave neighs/atom = 89.8465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.728515828424, Press = 1.2974312417169
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17515.998     -17515.998     -17656.341     -17656.341      271.50318      271.50318      44098.819      44098.819      123.00371      123.00371    
     45000  -17515.092     -17515.092     -17655.463     -17655.463      271.55675      271.55675      44132.192      44132.192     -1105.2303     -1105.2303    
Loop time of 476.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.398 hours/ns, 2.098 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 475.64     | 475.64     | 475.64     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14674    | 0.14674    | 0.14674    |   0.0 |  0.03
Output  | 0.00024458 | 0.00024458 | 0.00024458 |   0.0 |  0.00
Modify  | 0.73813    | 0.73813    | 0.73813    |   0.0 |  0.15
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358618 ave      358618 max      358618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358618
Ave neighs/atom = 89.6545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.741112193471, Press = -1.31340945301222
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17515.092     -17515.092     -17655.463     -17655.463      271.55675      271.55675      44132.192      44132.192     -1105.2303     -1105.2303    
     46000  -17515.15      -17515.15      -17655.037     -17655.037      270.62078      270.62078      44074.659      44074.659      1251.153       1251.153     
Loop time of 472.227 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.174 hours/ns, 2.118 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.24     | 471.24     | 471.24     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14628    | 0.14628    | 0.14628    |   0.0 |  0.03
Output  | 0.00019138 | 0.00019138 | 0.00019138 |   0.0 |  0.00
Modify  | 0.73535    | 0.73535    | 0.73535    |   0.0 |  0.16
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358056 ave      358056 max      358056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358056
Ave neighs/atom = 89.514
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.746115785836, Press = -0.587897029467359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17515.15      -17515.15      -17655.037     -17655.037      270.62078      270.62078      44074.659      44074.659      1251.153       1251.153     
     47000  -17511.848     -17511.848     -17653.861     -17653.861      274.73456      274.73456      44109.594      44109.594     -43.589843     -43.589843    
Loop time of 478.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.824 hours/ns, 2.091 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 477.17     | 477.17     | 477.17     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14693    | 0.14693    | 0.14693    |   0.0 |  0.03
Output  | 0.00018904 | 0.00018904 | 0.00018904 |   0.0 |  0.00
Modify  | 0.74604    | 0.74604    | 0.74604    |   0.0 |  0.16
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359338 ave      359338 max      359338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359338
Ave neighs/atom = 89.8345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.752315876108, Press = -0.165899762722555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17511.848     -17511.848     -17653.861     -17653.861      274.73456      274.73456      44109.594      44109.594     -43.589843     -43.589843    
     48000  -17516.74      -17516.74      -17659.131     -17659.131      275.46369      275.46369      44102.828      44102.828     -329.47517     -329.47517    
Loop time of 470.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 130.811 hours/ns, 2.123 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 469.95     | 469.95     | 469.95     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14513    | 0.14513    | 0.14513    |   0.0 |  0.03
Output  | 0.00018887 | 0.00018887 | 0.00018887 |   0.0 |  0.00
Modify  | 0.73019    | 0.73019    | 0.73019    |   0.0 |  0.16
Other   |            | 0.1003     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358760 ave      358760 max      358760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358760
Ave neighs/atom = 89.69
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.802595909242, Press = -0.695960698522186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17516.74      -17516.74      -17659.131     -17659.131      275.46369      275.46369      44102.828      44102.828     -329.47517     -329.47517    
     49000  -17513.54      -17513.54      -17655.541     -17655.541      274.71154      274.71154      44104.509      44104.509      12.636018      12.636018    
Loop time of 473.469 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.519 hours/ns, 2.112 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 472.48     | 472.48     | 472.48     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14721    | 0.14721    | 0.14721    |   0.0 |  0.03
Output  | 0.00018905 | 0.00018905 | 0.00018905 |   0.0 |  0.00
Modify  | 0.73793    | 0.73793    | 0.73793    |   0.0 |  0.16
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358048 ave      358048 max      358048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358048
Ave neighs/atom = 89.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.822702298644, Press = -0.677509541937517
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17513.54      -17513.54      -17655.541     -17655.541      274.71154      274.71154      44104.509      44104.509      12.636018      12.636018    
     50000  -17519.357     -17519.357     -17658.676     -17658.676      269.52237      269.52237      44067.468      44067.468      1149.5489      1149.5489    
Loop time of 474.615 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.838 hours/ns, 2.107 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 473.63     | 473.63     | 473.63     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14705    | 0.14705    | 0.14705    |   0.0 |  0.03
Output  | 0.000235   | 0.000235   | 0.000235   |   0.0 |  0.00
Modify  | 0.7349     | 0.7349     | 0.7349     |   0.0 |  0.15
Other   |            | 0.1005     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358232 ave      358232 max      358232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358232
Ave neighs/atom = 89.558
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.832806992428, Press = -0.337983942053215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17519.357     -17519.357     -17658.676     -17658.676      269.52237      269.52237      44067.468      44067.468      1149.5489      1149.5489    
     51000  -17515.019     -17515.019     -17658.212     -17658.212      277.01613      277.01613      44125.647      44125.647     -1130.5247     -1130.5247    
Loop time of 472.288 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.191 hours/ns, 2.117 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.31     | 471.31     | 471.31     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14506    | 0.14506    | 0.14506    |   0.0 |  0.03
Output  | 0.00019222 | 0.00019222 | 0.00019222 |   0.0 |  0.00
Modify  | 0.73491    | 0.73491    | 0.73491    |   0.0 |  0.16
Other   |            | 0.1015     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358368 ave      358368 max      358368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358368
Ave neighs/atom = 89.592
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.828398999751, Press = 0.0986027106163969
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17515.019     -17515.019     -17658.212     -17658.212      277.01613      277.01613      44125.647      44125.647     -1130.5247     -1130.5247    
     52000  -17520.074     -17520.074     -17658.055     -17658.055      266.93371      266.93371      44100.513      44100.513     -189.98205     -189.98205    
Loop time of 467.396 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.832 hours/ns, 2.140 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 466.43     | 466.43     | 466.43     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14506    | 0.14506    | 0.14506    |   0.0 |  0.03
Output  | 0.00023149 | 0.00023149 | 0.00023149 |   0.0 |  0.00
Modify  | 0.72373    | 0.72373    | 0.72373    |   0.0 |  0.15
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357360 ave      357360 max      357360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357360
Ave neighs/atom = 89.34
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.805774685513, Press = -1.29876857787162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17520.074     -17520.074     -17658.055     -17658.055      266.93371      266.93371      44100.513      44100.513     -189.98205     -189.98205    
     53000  -17514.405     -17514.405     -17657.291     -17657.291      276.42269      276.42269      44065.945      44065.945      1450.1266      1450.1266    
Loop time of 468.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.213 hours/ns, 2.133 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 467.8      | 467.8      | 467.8      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14373    | 0.14373    | 0.14373    |   0.0 |  0.03
Output  | 0.00019321 | 0.00019321 | 0.00019321 |   0.0 |  0.00
Modify  | 0.72068    | 0.72068    | 0.72068    |   0.0 |  0.15
Other   |            | 0.1003     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358314 ave      358314 max      358314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358314
Ave neighs/atom = 89.5785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.792056909062, Press = -0.0220909277990996
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17514.405     -17514.405     -17657.291     -17657.291      276.42269      276.42269      44065.945      44065.945      1450.1266      1450.1266    
     54000  -17515.976     -17515.976     -17657.758     -17657.758      274.28748      274.28748      44154.69       44154.69      -2284.2718     -2284.2718    
Loop time of 474.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.870 hours/ns, 2.106 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 473.75     | 473.75     | 473.75     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1458     | 0.1458     | 0.1458     |   0.0 |  0.03
Output  | 0.00019071 | 0.00019071 | 0.00019071 |   0.0 |  0.00
Modify  | 0.73669    | 0.73669    | 0.73669    |   0.0 |  0.16
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358726 ave      358726 max      358726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358726
Ave neighs/atom = 89.6815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.796164145659, Press = 0.190806214536126
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17515.976     -17515.976     -17657.758     -17657.758      274.28748      274.28748      44154.69       44154.69      -2284.2718     -2284.2718    
     55000  -17515.555     -17515.555     -17657.444     -17657.444      274.49418      274.49418      44106.089      44106.089     -224.30672     -224.30672    
Loop time of 469.374 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.382 hours/ns, 2.130 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 468.4      | 468.4      | 468.4      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14486    | 0.14486    | 0.14486    |   0.0 |  0.03
Output  | 0.00019709 | 0.00019709 | 0.00019709 |   0.0 |  0.00
Modify  | 0.72891    | 0.72891    | 0.72891    |   0.0 |  0.16
Other   |            | 0.09992    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357236 ave      357236 max      357236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357236
Ave neighs/atom = 89.309
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.785685470846, Press = -2.60594931844479
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17515.555     -17515.555     -17657.444     -17657.444      274.49418      274.49418      44106.089      44106.089     -224.30672     -224.30672    
     56000  -17513.582     -17513.582     -17655.639     -17655.639      274.81938      274.81938      44077.736      44077.736      1151.6824      1151.6824    
Loop time of 476.284 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.301 hours/ns, 2.100 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 475.29     | 475.29     | 475.29     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14768    | 0.14768    | 0.14768    |   0.0 |  0.03
Output  | 0.00018821 | 0.00018821 | 0.00018821 |   0.0 |  0.00
Modify  | 0.74504    | 0.74504    | 0.74504    |   0.0 |  0.16
Other   |            | 0.1022     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357916 ave      357916 max      357916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357916
Ave neighs/atom = 89.479
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.764697045435, Press = 0.220196364826844
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17513.582     -17513.582     -17655.639     -17655.639      274.81938      274.81938      44077.736      44077.736      1151.6824      1151.6824    
     57000  -17517.728     -17517.728     -17657.741     -17657.741      270.86564      270.86564      44124.166      44124.166     -1087.0835     -1087.0835    
Loop time of 475.566 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 132.102 hours/ns, 2.103 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 474.58     | 474.58     | 474.58     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14613    | 0.14613    | 0.14613    |   0.0 |  0.03
Output  | 0.00018952 | 0.00018952 | 0.00018952 |   0.0 |  0.00
Modify  | 0.74299    | 0.74299    | 0.74299    |   0.0 |  0.16
Other   |            | 0.1013     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358466 ave      358466 max      358466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358466
Ave neighs/atom = 89.6165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.772848032732, Press = -0.431807255630608
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17517.728     -17517.728     -17657.741     -17657.741      270.86564      270.86564      44124.166      44124.166     -1087.0835     -1087.0835    
     58000  -17512.917     -17512.917     -17658.421     -17658.421      281.48757      281.48757      44079.491      44079.491      834.78006      834.78006    
Loop time of 464.201 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.945 hours/ns, 2.154 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 463.24     | 463.24     | 463.24     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14436    | 0.14436    | 0.14436    |   0.0 |  0.03
Output  | 0.00018858 | 0.00018858 | 0.00018858 |   0.0 |  0.00
Modify  | 0.71872    | 0.71872    | 0.71872    |   0.0 |  0.15
Other   |            | 0.1008     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357612 ave      357612 max      357612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357612
Ave neighs/atom = 89.403
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.803421403794, Press = -0.634693576119741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17512.917     -17512.917     -17658.421     -17658.421      281.48757      281.48757      44079.491      44079.491      834.78006      834.78006    
     59000  -17518.294     -17518.294     -17657.049     -17657.049      268.42949      268.42949      44104.633      44104.633     -283.85495     -283.85495    
Loop time of 472.29 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.192 hours/ns, 2.117 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.31     | 471.31     | 471.31     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14588    | 0.14588    | 0.14588    |   0.0 |  0.03
Output  | 0.00019004 | 0.00019004 | 0.00019004 |   0.0 |  0.00
Modify  | 0.73427    | 0.73427    | 0.73427    |   0.0 |  0.16
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358656 ave      358656 max      358656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358656
Ave neighs/atom = 89.664
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.833280228296, Press = 0.608694868571215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -17518.294     -17518.294     -17657.049     -17657.049      268.42949      268.42949      44104.633      44104.633     -283.85495     -283.85495    
     60000  -17516.344     -17516.344     -17655.048     -17655.048      268.33065      268.33065      44146.857      44146.857     -1864.25       -1864.25      
Loop time of 474.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 131.808 hours/ns, 2.107 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 473.52     | 473.52     | 473.52     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14641    | 0.14641    | 0.14641    |   0.0 |  0.03
Output  | 0.00019074 | 0.00019074 | 0.00019074 |   0.0 |  0.00
Modify  | 0.73703    | 0.73703    | 0.73703    |   0.0 |  0.16
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358524 ave      358524 max      358524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358524
Ave neighs/atom = 89.631
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.8466222561, Press = -1.46524634895946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -17516.344     -17516.344     -17655.048     -17655.048      268.33065      268.33065      44146.857      44146.857     -1864.25       -1864.25      
     61000  -17519.688     -17519.688     -17660.421     -17660.421      272.25811      272.25811      44053.951      44053.951      1504.902       1504.902     
Loop time of 472.809 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.336 hours/ns, 2.115 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.82     | 471.82     | 471.82     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14706    | 0.14706    | 0.14706    |   0.0 |  0.03
Output  | 0.00018981 | 0.00018981 | 0.00018981 |   0.0 |  0.00
Modify  | 0.73836    | 0.73836    | 0.73836    |   0.0 |  0.16
Other   |            | 0.1016     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358158 ave      358158 max      358158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358158
Ave neighs/atom = 89.5395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.807503762077, Press = -0.255987334017038
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -17519.688     -17519.688     -17660.421     -17660.421      272.25811      272.25811      44053.951      44053.951      1504.902       1504.902     
     62000  -17515.115     -17515.115     -17658.248     -17658.248      276.9008       276.9008       44111.948      44111.948     -556.42557     -556.42557    
Loop time of 472.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.379 hours/ns, 2.114 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.98     | 471.98     | 471.98     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14655    | 0.14655    | 0.14655    |   0.0 |  0.03
Output  | 0.0002233  | 0.0002233  | 0.0002233  |   0.0 |  0.00
Modify  | 0.7344     | 0.7344     | 0.7344     |   0.0 |  0.16
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358758 ave      358758 max      358758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358758
Ave neighs/atom = 89.6895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.801472085852, Press = -0.160781379240806
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -17515.115     -17515.115     -17658.248     -17658.248      276.9008       276.9008       44111.948      44111.948     -556.42557     -556.42557    
     63000  -17519.111     -17519.111     -17657.675     -17657.675      268.06218      268.06218      44095.08       44095.08       95.904937      95.904937    
Loop time of 475.489 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.182 ns/day, 132.080 hours/ns, 2.103 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 474.49     | 474.49     | 474.49     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1479     | 0.1479     | 0.1479     |   0.0 |  0.03
Output  | 0.0001906  | 0.0001906  | 0.0001906  |   0.0 |  0.00
Modify  | 0.74801    | 0.74801    | 0.74801    |   0.0 |  0.16
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357960 ave      357960 max      357960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357960
Ave neighs/atom = 89.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.774918686052, Press = -0.567518036945505
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -17519.111     -17519.111     -17657.675     -17657.675      268.06218      268.06218      44095.08       44095.08       95.904937      95.904937    
     64000  -17516.279     -17516.279     -17657.767     -17657.767      273.71903      273.71903      44063.501      44063.501      1497.6629      1497.6629    
Loop time of 471.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 130.980 hours/ns, 2.121 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 470.55     | 470.55     | 470.55     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14584    | 0.14584    | 0.14584    |   0.0 |  0.03
Output  | 0.00023805 | 0.00023805 | 0.00023805 |   0.0 |  0.00
Modify  | 0.73285    | 0.73285    | 0.73285    |   0.0 |  0.16
Other   |            | 0.1009     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358030 ave      358030 max      358030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358030
Ave neighs/atom = 89.5075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.778470438773, Press = 0.0685867952123375
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -17516.279     -17516.279     -17657.767     -17657.767      273.71903      273.71903      44063.501      44063.501      1497.6629      1497.6629    
     65000  -17518.161     -17518.161     -17656.867     -17656.867      268.33711      268.33711      44153.625      44153.625     -2265.9454     -2265.9454    
Loop time of 468.592 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.164 hours/ns, 2.134 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 467.62     | 467.62     | 467.62     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14503    | 0.14503    | 0.14503    |   0.0 |  0.03
Output  | 0.00019075 | 0.00019075 | 0.00019075 |   0.0 |  0.00
Modify  | 0.72627    | 0.72627    | 0.72627    |   0.0 |  0.15
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358684 ave      358684 max      358684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358684
Ave neighs/atom = 89.671
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.777642865997, Press = 0.179094233408256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -17518.161     -17518.161     -17656.867     -17656.867      268.33711      268.33711      44153.625      44153.625     -2265.9454     -2265.9454    
     66000  -17514.543     -17514.543     -17656.696     -17656.696      275.00586      275.00586      44095.003      44095.003      286.76341      286.76341    
Loop time of 471.773 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.048 hours/ns, 2.120 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 470.79     | 470.79     | 470.79     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14598    | 0.14598    | 0.14598    |   0.0 |  0.03
Output  | 0.00019038 | 0.00019038 | 0.00019038 |   0.0 |  0.00
Modify  | 0.73469    | 0.73469    | 0.73469    |   0.0 |  0.16
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357952 ave      357952 max      357952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357952
Ave neighs/atom = 89.488
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.788032367154, Press = -1.1457329502305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -17514.543     -17514.543     -17656.696     -17656.696      275.00586      275.00586      44095.003      44095.003      286.76341      286.76341    
     67000  -17516.029     -17516.029     -17655.803     -17655.803      270.4018       270.4018       44083.927      44083.927      805.53754      805.53754    
Loop time of 466.423 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.562 hours/ns, 2.144 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 465.46     | 465.46     | 465.46     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1434     | 0.1434     | 0.1434     |   0.0 |  0.03
Output  | 0.00019039 | 0.00019039 | 0.00019039 |   0.0 |  0.00
Modify  | 0.71861    | 0.71861    | 0.71861    |   0.0 |  0.15
Other   |            | 0.09954    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358442 ave      358442 max      358442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358442
Ave neighs/atom = 89.6105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.785260819819, Press = 0.0933283614867354
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -17516.029     -17516.029     -17655.803     -17655.803      270.4018       270.4018       44083.927      44083.927      805.53754      805.53754    
     68000  -17515.45      -17515.45      -17653.978     -17653.978      267.99245      267.99245      44113.791      44113.791     -346.86496     -346.86496    
Loop time of 461.459 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.183 hours/ns, 2.167 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 460.51     | 460.51     | 460.51     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14189    | 0.14189    | 0.14189    |   0.0 |  0.03
Output  | 0.00024575 | 0.00024575 | 0.00024575 |   0.0 |  0.00
Modify  | 0.70996    | 0.70996    | 0.70996    |   0.0 |  0.15
Other   |            | 0.1003     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358814 ave      358814 max      358814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358814
Ave neighs/atom = 89.7035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.796484652571, Press = -0.274436875118403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -17515.45      -17515.45      -17653.978     -17653.978      267.99245      267.99245      44113.791      44113.791     -346.86496     -346.86496    
     69000  -17515.96      -17515.96      -17657.13      -17657.13       273.10336      273.10336      44087.075      44087.075      505.93454      505.93454    
Loop time of 461.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.308 hours/ns, 2.165 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 460.96     | 460.96     | 460.96     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14323    | 0.14323    | 0.14323    |   0.0 |  0.03
Output  | 0.00019042 | 0.00019042 | 0.00019042 |   0.0 |  0.00
Modify  | 0.7101     | 0.7101     | 0.7101     |   0.0 |  0.15
Other   |            | 0.09934    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358798 ave      358798 max      358798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358798
Ave neighs/atom = 89.6995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.80627202993, Press = -0.37941771865253
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -17515.96      -17515.96      -17657.13      -17657.13       273.10336      273.10336      44087.075      44087.075      505.93454      505.93454    
     70000  -17520.077     -17520.077     -17658.243     -17658.243      267.29188      267.29188      44085.107      44085.107      385.35493      385.35493    
Loop time of 469.46 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.406 hours/ns, 2.130 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 468.49     | 468.49     | 468.49     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14457    | 0.14457    | 0.14457    |   0.0 |  0.03
Output  | 0.00024812 | 0.00024812 | 0.00024812 |   0.0 |  0.00
Modify  | 0.72767    | 0.72767    | 0.72767    |   0.0 |  0.16
Other   |            | 0.1007     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358578 ave      358578 max      358578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358578
Ave neighs/atom = 89.6445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.821560780698, Press = 0.403617465778621
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -17520.077     -17520.077     -17658.243     -17658.243      267.29188      267.29188      44085.107      44085.107      385.35493      385.35493    
     71000  -17514.686     -17514.686     -17656.248     -17656.248      273.86049      273.86049      44164.333      44164.333     -2558.5567     -2558.5567    
Loop time of 465.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.392 hours/ns, 2.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 464.85     | 464.85     | 464.85     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14413    | 0.14413    | 0.14413    |   0.0 |  0.03
Output  | 0.00023187 | 0.00023187 | 0.00023187 |   0.0 |  0.00
Modify  | 0.71913    | 0.71913    | 0.71913    |   0.0 |  0.15
Other   |            | 0.1007     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358698 ave      358698 max      358698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358698
Ave neighs/atom = 89.6745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.807772760533, Press = -0.945632503445269
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -17514.686     -17514.686     -17656.248     -17656.248      273.86049      273.86049      44164.333      44164.333     -2558.5567     -2558.5567    
     72000  -17519.044     -17519.044     -17657.386     -17657.386      267.63231      267.63231      44050.717      44050.717      1998.9663      1998.9663    
Loop time of 463.589 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.775 hours/ns, 2.157 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 462.63     | 462.63     | 462.63     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14449    | 0.14449    | 0.14449    |   0.0 |  0.03
Output  | 0.00018999 | 0.00018999 | 0.00018999 |   0.0 |  0.00
Modify  | 0.71313    | 0.71313    | 0.71313    |   0.0 |  0.15
Other   |            | 0.1002     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357452 ave      357452 max      357452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357452
Ave neighs/atom = 89.363
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.786917063363, Press = -0.351403299013642
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -17519.044     -17519.044     -17657.386     -17657.386      267.63231      267.63231      44050.717      44050.717      1998.9663      1998.9663    
     73000  -17517.228     -17517.228     -17657.572     -17657.572      271.50634      271.50634      44112.364      44112.364     -529.36437     -529.36437    
Loop time of 468.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.192 hours/ns, 2.134 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 467.71     | 467.71     | 467.71     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14483    | 0.14483    | 0.14483    |   0.0 |  0.03
Output  | 0.00019309 | 0.00019309 | 0.00019309 |   0.0 |  0.00
Modify  | 0.73299    | 0.73299    | 0.73299    |   0.0 |  0.16
Other   |            | 0.1014     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359524 ave      359524 max      359524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359524
Ave neighs/atom = 89.881
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.795688791789, Press = 0.148551313218305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -17517.228     -17517.228     -17657.572     -17657.572      271.50634      271.50634      44112.364      44112.364     -529.36437     -529.36437    
     74000  -17515.346     -17515.346     -17657.758     -17657.758      275.50499      275.50499      44119.978      44119.978     -750.98266     -750.98266    
Loop time of 465.814 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.393 hours/ns, 2.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 464.85     | 464.85     | 464.85     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14415    | 0.14415    | 0.14415    |   0.0 |  0.03
Output  | 0.0002367  | 0.0002367  | 0.0002367  |   0.0 |  0.00
Modify  | 0.71981    | 0.71981    | 0.71981    |   0.0 |  0.15
Other   |            | 0.1003     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357938 ave      357938 max      357938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357938
Ave neighs/atom = 89.4845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.809399456099, Press = -0.679587613992116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -17515.346     -17515.346     -17657.758     -17657.758      275.50499      275.50499      44119.978      44119.978     -750.98266     -750.98266    
     75000  -17519.722     -17519.722     -17658.717     -17658.717      268.89602      268.89602      44064.446      44064.446      1347.4904      1347.4904    
Loop time of 465.359 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.266 hours/ns, 2.149 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 464.4      | 464.4      | 464.4      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14306    | 0.14306    | 0.14306    |   0.0 |  0.03
Output  | 0.00024164 | 0.00024164 | 0.00024164 |   0.0 |  0.00
Modify  | 0.71497    | 0.71497    | 0.71497    |   0.0 |  0.15
Other   |            | 0.09982    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357614 ave      357614 max      357614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357614
Ave neighs/atom = 89.4035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824886809672, Press = -0.0223381051831964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -17519.722     -17519.722     -17658.717     -17658.717      268.89602      268.89602      44064.446      44064.446      1347.4904      1347.4904    
     76000  -17514.57      -17514.57      -17656.325     -17656.325      274.23462      274.23462      44127.912      44127.912     -1062.3063     -1062.3063    
Loop time of 463.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.734 hours/ns, 2.158 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 462.49     | 462.49     | 462.49     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14109    | 0.14109    | 0.14109    |   0.0 |  0.03
Output  | 0.00018723 | 0.00018723 | 0.00018723 |   0.0 |  0.00
Modify  | 0.70873    | 0.70873    | 0.70873    |   0.0 |  0.15
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358822 ave      358822 max      358822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358822
Ave neighs/atom = 89.7055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.814449748107, Press = 0.0455734152012535
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -17514.57      -17514.57      -17656.325     -17656.325      274.23462      274.23462      44127.912      44127.912     -1062.3063     -1062.3063    
     77000  -17519.56      -17519.56      -17658.681     -17658.681      269.13863      269.13863      44097.427      44097.427     -67.029134     -67.029134    
Loop time of 463.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.829 hours/ns, 2.156 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 462.83     | 462.83     | 462.83     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14374    | 0.14374    | 0.14374    |   0.0 |  0.03
Output  | 0.00023546 | 0.00023546 | 0.00023546 |   0.0 |  0.00
Modify  | 0.71409    | 0.71409    | 0.71409    |   0.0 |  0.15
Other   |            | 0.09975    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358142 ave      358142 max      358142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358142
Ave neighs/atom = 89.5355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.792303037603, Press = -1.14441374236709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -17519.56      -17519.56      -17658.681     -17658.681      269.13863      269.13863      44097.427      44097.427     -67.029134     -67.029134    
     78000  -17516.88      -17516.88      -17658.281     -17658.281      273.55142      273.55142      44008.459      44008.459      3755.1788      3755.1788    
Loop time of 468.673 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.187 hours/ns, 2.134 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 467.7      | 467.7      | 467.7      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14447    | 0.14447    | 0.14447    |   0.0 |  0.03
Output  | 0.00019212 | 0.00019212 | 0.00019212 |   0.0 |  0.00
Modify  | 0.72641    | 0.72641    | 0.72641    |   0.0 |  0.15
Other   |            | 0.1004     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358084 ave      358084 max      358084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358084
Ave neighs/atom = 89.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.80305441612, Press = 0.950009891056253
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -17516.88      -17516.88      -17658.281     -17658.281      273.55142      273.55142      44008.459      44008.459      3755.1788      3755.1788    
     79000  -17510.947     -17510.947     -17652.482     -17652.482      273.81088      273.81088      44138.298      44138.298     -1164.1209     -1164.1209    
Loop time of 467.785 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.940 hours/ns, 2.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 466.82     | 466.82     | 466.82     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14515    | 0.14515    | 0.14515    |   0.0 |  0.03
Output  | 0.00019036 | 0.00019036 | 0.00019036 |   0.0 |  0.00
Modify  | 0.7244     | 0.7244     | 0.7244     |   0.0 |  0.15
Other   |            | 0.1001     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359994 ave      359994 max      359994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359994
Ave neighs/atom = 89.9985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.82491388175, Press = 0.0494074388337831
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -17510.947     -17510.947     -17652.482     -17652.482      273.81088      273.81088      44138.298      44138.298     -1164.1209     -1164.1209    
     80000  -17516.336     -17516.336     -17658.792     -17658.792      275.59061      275.59061      44106.262      44106.262     -356.3063      -356.3063     
Loop time of 467.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.951 hours/ns, 2.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 466.85     | 466.85     | 466.85     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14531    | 0.14531    | 0.14531    |   0.0 |  0.03
Output  | 0.00019111 | 0.00019111 | 0.00019111 |   0.0 |  0.00
Modify  | 0.72616    | 0.72616    | 0.72616    |   0.0 |  0.16
Other   |            | 0.1005     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358654 ave      358654 max      358654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358654
Ave neighs/atom = 89.6635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.846797344608, Press = -0.510095743579651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -17516.336     -17516.336     -17658.792     -17658.792      275.59061      275.59061      44106.262      44106.262     -356.3063      -356.3063     
     81000  -17514.718     -17514.718     -17655.184     -17655.184      271.74112      271.74112      44079.873      44079.873      1008.0573      1008.0573    
Loop time of 466.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.546 hours/ns, 2.144 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 465.4      | 465.4      | 465.4      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14541    | 0.14541    | 0.14541    |   0.0 |  0.03
Output  | 0.00018997 | 0.00018997 | 0.00018997 |   0.0 |  0.00
Modify  | 0.72386    | 0.72386    | 0.72386    |   0.0 |  0.16
Other   |            | 0.1005     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357952 ave      357952 max      357952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357952
Ave neighs/atom = 89.488
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.850054586917, Press = 0.156086323048892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -17514.718     -17514.718     -17655.184     -17655.184      271.74112      271.74112      44079.873      44079.873      1008.0573      1008.0573    
     82000  -17519.696     -17519.696     -17656.888     -17656.888      265.40692      265.40692      44147.334      44147.334     -2055.5573     -2055.5573    
Loop time of 476.823 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.451 hours/ns, 2.097 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 475.83     | 475.83     | 475.83     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14709    | 0.14709    | 0.14709    |   0.0 |  0.03
Output  | 0.00019057 | 0.00019057 | 0.00019057 |   0.0 |  0.00
Modify  | 0.74734    | 0.74734    | 0.74734    |   0.0 |  0.16
Other   |            | 0.1015     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359632 ave      359632 max      359632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359632
Ave neighs/atom = 89.908
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.848219710871, Press = -0.0402006394610209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -17519.696     -17519.696     -17656.888     -17656.888      265.40692      265.40692      44147.334      44147.334     -2055.5573     -2055.5573    
     83000  -17512.969     -17512.969     -17655.998     -17655.998      276.69984      276.69984      44073.756      44073.756      1380.6822      1380.6822    
Loop time of 460.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.824 hours/ns, 2.173 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 459.21     | 459.21     | 459.21     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14208    | 0.14208    | 0.14208    |   0.0 |  0.03
Output  | 0.00019185 | 0.00019185 | 0.00019185 |   0.0 |  0.00
Modify  | 0.71069    | 0.71069    | 0.71069    |   0.0 |  0.15
Other   |            | 0.09983    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357822 ave      357822 max      357822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357822
Ave neighs/atom = 89.4555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.854362168531, Press = -0.933787233526952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -17512.969     -17512.969     -17655.998     -17655.998      276.69984      276.69984      44073.756      44073.756      1380.6822      1380.6822    
     84000  -17518.437     -17518.437     -17658.496     -17658.496      270.95313      270.95313      44078.372      44078.372      777.72705      777.72705    
Loop time of 464.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.078 hours/ns, 2.152 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 463.72     | 463.72     | 463.72     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1445     | 0.1445     | 0.1445     |   0.0 |  0.03
Output  | 0.00019027 | 0.00019027 | 0.00019027 |   0.0 |  0.00
Modify  | 0.7209     | 0.7209     | 0.7209     |   0.0 |  0.16
Other   |            | 0.1007     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358886 ave      358886 max      358886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358886
Ave neighs/atom = 89.7215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.856597025211, Press = 0.434774313962633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -17518.437     -17518.437     -17658.496     -17658.496      270.95313      270.95313      44078.372      44078.372      777.72705      777.72705    
     85000  -17513.485     -17513.485     -17656.41      -17656.41       276.4982       276.4982       44126.514      44126.514     -926.90154     -926.90154    
Loop time of 463.023 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.618 hours/ns, 2.160 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 462.07     | 462.07     | 462.07     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14368    | 0.14368    | 0.14368    |   0.0 |  0.03
Output  | 0.00024318 | 0.00024318 | 0.00024318 |   0.0 |  0.00
Modify  | 0.71257    | 0.71257    | 0.71257    |   0.0 |  0.15
Other   |            | 0.09997    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358674 ave      358674 max      358674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358674
Ave neighs/atom = 89.6685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.856800598938, Press = -0.235486422682576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -17513.485     -17513.485     -17656.41      -17656.41       276.4982       276.4982       44126.514      44126.514     -926.90154     -926.90154    
     86000  -17519.757     -17519.757     -17658.888     -17658.888      269.15823      269.15823      44075.376      44075.376      863.65443      863.65443    
Loop time of 466.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.651 hours/ns, 2.143 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 465.77     | 465.77     | 465.77     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14481    | 0.14481    | 0.14481    |   0.0 |  0.03
Output  | 0.00024435 | 0.00024435 | 0.00024435 |   0.0 |  0.00
Modify  | 0.72377    | 0.72377    | 0.72377    |   0.0 |  0.16
Other   |            | 0.1009     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358330 ave      358330 max      358330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358330
Ave neighs/atom = 89.5825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.85312222099, Press = -0.257809821202078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -17519.757     -17519.757     -17658.888     -17658.888      269.15823      269.15823      44075.376      44075.376      863.65443      863.65443    
     87000  -17515.212     -17515.212     -17656.713     -17656.713      273.74223      273.74223      44092.451      44092.451      420.48578      420.48578    
Loop time of 464.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.163 hours/ns, 2.151 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 464.02     | 464.02     | 464.02     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14441    | 0.14441    | 0.14441    |   0.0 |  0.03
Output  | 0.0001909  | 0.0001909  | 0.0001909  |   0.0 |  0.00
Modify  | 0.718      | 0.718      | 0.718      |   0.0 |  0.15
Other   |            | 0.1004     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358302 ave      358302 max      358302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358302
Ave neighs/atom = 89.5755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.847023107638, Press = 0.391901984244973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -17515.212     -17515.212     -17656.713     -17656.713      273.74223      273.74223      44092.451      44092.451      420.48578      420.48578    
     88000  -17520.515     -17520.515     -17659.12      -17659.12       268.14175      268.14175      44173.563      44173.563     -3277.2834     -3277.2834    
Loop time of 458.131 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.259 hours/ns, 2.183 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 457.19     | 457.19     | 457.19     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14254    | 0.14254    | 0.14254    |   0.0 |  0.03
Output  | 0.00024242 | 0.00024242 | 0.00024242 |   0.0 |  0.00
Modify  | 0.69611    | 0.69611    | 0.69611    |   0.0 |  0.15
Other   |            | 0.09897    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358784 ave      358784 max      358784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358784
Ave neighs/atom = 89.696
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.830780799705, Press = -0.520763622808625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -17520.515     -17520.515     -17659.12      -17659.12       268.14175      268.14175      44173.563      44173.563     -3277.2834     -3277.2834    
     89000  -17513.987     -17513.987     -17657.83      -17657.83       278.27355      278.27355      44061.979      44061.979      1585.2411      1585.2411    
Loop time of 456.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 126.697 hours/ns, 2.192 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 455.17     | 455.17     | 455.17     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14209    | 0.14209    | 0.14209    |   0.0 |  0.03
Output  | 0.00019092 | 0.00019092 | 0.00019092 |   0.0 |  0.00
Modify  | 0.70051    | 0.70051    | 0.70051    |   0.0 |  0.15
Other   |            | 0.09968    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356792 ave      356792 max      356792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356792
Ave neighs/atom = 89.198
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.831319864498, Press = -0.418055510005427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -17513.987     -17513.987     -17657.83      -17657.83       278.27355      278.27355      44061.979      44061.979      1585.2411      1585.2411    
     90000  -17516.914     -17516.914     -17659.253     -17659.253      275.36507      275.36507      44101.25       44101.25      -195.89033     -195.89033    
Loop time of 464.096 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.916 hours/ns, 2.155 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 463.14     | 463.14     | 463.14     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14285    | 0.14285    | 0.14285    |   0.0 |  0.03
Output  | 0.00018968 | 0.00018968 | 0.00018968 |   0.0 |  0.00
Modify  | 0.71467    | 0.71467    | 0.71467    |   0.0 |  0.15
Other   |            | 0.1003     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359226 ave      359226 max      359226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359226
Ave neighs/atom = 89.8065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.813666974176, Press = 0.261301996348284
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -17516.914     -17516.914     -17659.253     -17659.253      275.36507      275.36507      44101.25       44101.25      -195.89033     -195.89033    
     91000  -17518.26      -17518.26      -17658.438     -17658.438      271.18365      271.18365      44115.301      44115.301     -763.53875     -763.53875    
Loop time of 463.323 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.701 hours/ns, 2.158 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 462.37     | 462.37     | 462.37     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14258    | 0.14258    | 0.14258    |   0.0 |  0.03
Output  | 0.00019086 | 0.00019086 | 0.00019086 |   0.0 |  0.00
Modify  | 0.71052    | 0.71052    | 0.71052    |   0.0 |  0.15
Other   |            | 0.09977    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358328 ave      358328 max      358328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358328
Ave neighs/atom = 89.582
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.812267461153, Press = -0.400788879384753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -17518.26      -17518.26      -17658.438     -17658.438      271.18365      271.18365      44115.301      44115.301     -763.53875     -763.53875    
     92000  -17512.523     -17512.523     -17655.247     -17655.247      276.10913      276.10913      44067.136      44067.136      1603.8398      1603.8398    
Loop time of 462.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.541 hours/ns, 2.161 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 461.79     | 461.79     | 461.79     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14351    | 0.14351    | 0.14351    |   0.0 |  0.03
Output  | 0.00023204 | 0.00023204 | 0.00023204 |   0.0 |  0.00
Modify  | 0.71411    | 0.71411    | 0.71411    |   0.0 |  0.15
Other   |            | 0.09943    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357756 ave      357756 max      357756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357756
Ave neighs/atom = 89.439
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.801586215708, Press = -0.064406824107768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -17512.523     -17512.523     -17655.247     -17655.247      276.10913      276.10913      44067.136      44067.136      1603.8398      1603.8398    
     93000  -17517.765     -17517.765     -17659.378     -17659.378      273.95996      273.95996      44122.828      44122.828     -1159.8331     -1159.8331    
Loop time of 463.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.772 hours/ns, 2.157 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 462.62     | 462.62     | 462.62     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14321    | 0.14321    | 0.14321    |   0.0 |  0.03
Output  | 0.0024692  | 0.0024692  | 0.0024692  |   0.0 |  0.00
Modify  | 0.71443    | 0.71443    | 0.71443    |   0.0 |  0.15
Other   |            | 0.1002     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359594 ave      359594 max      359594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359594
Ave neighs/atom = 89.8985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.817132409392, Press = 0.467180756355005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -17517.765     -17517.765     -17659.378     -17659.378      273.95996      273.95996      44122.828      44122.828     -1159.8331     -1159.8331    
     94000  -17512.856     -17512.856     -17656.273     -17656.273      277.44918      277.44918      44147.314      44147.314     -1805.9419     -1805.9419    
Loop time of 458.113 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.254 hours/ns, 2.183 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 457.17     | 457.17     | 457.17     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14142    | 0.14142    | 0.14142    |   0.0 |  0.03
Output  | 0.0001882  | 0.0001882  | 0.0001882  |   0.0 |  0.00
Modify  | 0.70109    | 0.70109    | 0.70109    |   0.0 |  0.15
Other   |            | 0.1003     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357842 ave      357842 max      357842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357842
Ave neighs/atom = 89.4605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.838049804858, Press = -1.02908026833651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -17512.856     -17512.856     -17656.273     -17656.273      277.44918      277.44918      44147.314      44147.314     -1805.9419     -1805.9419    
     95000  -17518.315     -17518.315     -17659.555     -17659.555      273.23767      273.23767      44058.922      44058.922      1476.146       1476.146     
Loop time of 458.747 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.430 hours/ns, 2.180 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 457.8      | 457.8      | 457.8      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14315    | 0.14315    | 0.14315    |   0.0 |  0.03
Output  | 0.00018832 | 0.00018832 | 0.00018832 |   0.0 |  0.00
Modify  | 0.7084     | 0.7084     | 0.7084     |   0.0 |  0.15
Other   |            | 0.09959    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357740 ave      357740 max      357740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357740
Ave neighs/atom = 89.435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.838815572158, Press = 0.112631243300879
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -17518.315     -17518.315     -17659.555     -17659.555      273.23767      273.23767      44058.922      44058.922      1476.146       1476.146     
     96000  -17513.568     -17513.568     -17654.802     -17654.802      273.22641      273.22641      44127.009      44127.009     -915.23541     -915.23541    
Loop time of 462.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.378 hours/ns, 2.164 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 461.21     | 461.21     | 461.21     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14258    | 0.14258    | 0.14258    |   0.0 |  0.03
Output  | 0.00019068 | 0.00019068 | 0.00019068 |   0.0 |  0.00
Modify  | 0.70888    | 0.70888    | 0.70888    |   0.0 |  0.15
Other   |            | 0.09867    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359294 ave      359294 max      359294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359294
Ave neighs/atom = 89.8235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.843601709764, Press = 0.103713152755559
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -17513.568     -17513.568     -17654.802     -17654.802      273.22641      273.22641      44127.009      44127.009     -915.23541     -915.23541    
     97000  -17510.49      -17510.49      -17653.257     -17653.257      276.19208      276.19208      44121.016      44121.016     -448.72606     -448.72606    
Loop time of 463.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.737 hours/ns, 2.158 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 462.5      | 462.5      | 462.5      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14291    | 0.14291    | 0.14291    |   0.0 |  0.03
Output  | 0.00024992 | 0.00024992 | 0.00024992 |   0.0 |  0.00
Modify  | 0.71302    | 0.71302    | 0.71302    |   0.0 |  0.15
Other   |            | 0.09932    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358738 ave      358738 max      358738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358738
Ave neighs/atom = 89.6845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.848824764723, Press = -0.402735357358912
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -17510.49      -17510.49      -17653.257     -17653.257      276.19208      276.19208      44121.016      44121.016     -448.72606     -448.72606    
     98000  -17517.927     -17517.927     -17658.091     -17658.091      271.15627      271.15627      44052.73       44052.73       1890.8761      1890.8761    
Loop time of 465.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.381 hours/ns, 2.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 464.81     | 464.81     | 464.81     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.144      | 0.144      | 0.144      |   0.0 |  0.03
Output  | 0.00023605 | 0.00023605 | 0.00023605 |   0.0 |  0.00
Modify  | 0.71899    | 0.71899    | 0.71899    |   0.0 |  0.15
Other   |            | 0.09934    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358802 ave      358802 max      358802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358802
Ave neighs/atom = 89.7005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.865928347355, Press = 0.206028945271182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -17517.927     -17517.927     -17658.091     -17658.091      271.15627      271.15627      44052.73       44052.73       1890.8761      1890.8761    
     99000  -17512.165     -17512.165     -17654.677     -17654.677      275.69954      275.69954      44177.891      44177.891     -2936.3906     -2936.3906    
Loop time of 462.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.580 hours/ns, 2.160 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 461.93     | 461.93     | 461.93     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14426    | 0.14426    | 0.14426    |   0.0 |  0.03
Output  | 0.00036282 | 0.00036282 | 0.00036282 |   0.0 |  0.00
Modify  | 0.7154     | 0.7154     | 0.7154     |   0.0 |  0.15
Other   |            | 0.09905    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359344 ave      359344 max      359344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359344
Ave neighs/atom = 89.836
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.885187320347, Press = 0.179740092449332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -17512.165     -17512.165     -17654.677     -17654.677      275.69954      275.69954      44177.891      44177.891     -2936.3906     -2936.3906    
    100000  -17516.253     -17516.253     -17659.068     -17659.068      276.28523      276.28523      44087.626      44087.626      373.73525      373.73525    
Loop time of 457.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.139 hours/ns, 2.185 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 456.76     | 456.76     | 456.76     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14096    | 0.14096    | 0.14096    |   0.0 |  0.03
Output  | 0.00023113 | 0.00023113 | 0.00023113 |   0.0 |  0.00
Modify  | 0.7054     | 0.7054     | 0.7054     |   0.0 |  0.15
Other   |            | 0.09909    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357200 ave      357200 max      357200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357200
Ave neighs/atom = 89.3
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.896340900058, Press = -0.545012204796535
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -17516.253     -17516.253     -17659.068     -17659.068      276.28523      276.28523      44087.626      44087.626      373.73525      373.73525    
    101000  -17514.564     -17514.564     -17655.997     -17655.997      273.61166      273.61166      44081.664      44081.664      944.36246      944.36246    
Loop time of 459.498 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.638 hours/ns, 2.176 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 458.56     | 458.56     | 458.56     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1416     | 0.1416     | 0.1416     |   0.0 |  0.03
Output  | 0.00023024 | 0.00023024 | 0.00023024 |   0.0 |  0.00
Modify  | 0.70102    | 0.70102    | 0.70102    |   0.0 |  0.15
Other   |            | 0.09938    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358068 ave      358068 max      358068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358068
Ave neighs/atom = 89.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.886194729459, Press = 0.20491359214079
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -17514.564     -17514.564     -17655.997     -17655.997      273.61166      273.61166      44081.664      44081.664      944.36246      944.36246    
    102000  -17519.24      -17519.24      -17659.248     -17659.248      270.85607      270.85607      44131.844      44131.844     -1584.3247     -1584.3247    
Loop time of 460.972 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.048 hours/ns, 2.169 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 460.02     | 460.02     | 460.02     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14358    | 0.14358    | 0.14358    |   0.0 |  0.03
Output  | 0.0001888  | 0.0001888  | 0.0001888  |   0.0 |  0.00
Modify  | 0.70839    | 0.70839    | 0.70839    |   0.0 |  0.15
Other   |            | 0.09984    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358976 ave      358976 max      358976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358976
Ave neighs/atom = 89.744
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.878254806462, Press = -0.179721080443569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -17519.24      -17519.24      -17659.248     -17659.248      270.85607      270.85607      44131.844      44131.844     -1584.3247     -1584.3247    
    103000  -17513.837     -17513.837     -17655.914     -17655.914      274.85763      274.85763      44066.148      44066.148      1524.0134      1524.0134    
Loop time of 464.761 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.100 hours/ns, 2.152 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 463.79     | 463.79     | 463.79     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14401    | 0.14401    | 0.14401    |   0.0 |  0.03
Output  | 0.00019394 | 0.00019394 | 0.00019394 |   0.0 |  0.00
Modify  | 0.72295    | 0.72295    | 0.72295    |   0.0 |  0.16
Other   |            | 0.1004     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357408 ave      357408 max      357408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357408
Ave neighs/atom = 89.352
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.880289982328, Press = -0.21424851979478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -17513.837     -17513.837     -17655.914     -17655.914      274.85763      274.85763      44066.148      44066.148      1524.0134      1524.0134    
    104000  -17516.57      -17516.57      -17658.48      -17658.48       274.53566      274.53566      44110.135      44110.135     -465.3979      -465.3979     
Loop time of 462.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.487 hours/ns, 2.162 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 461.6      | 461.6      | 461.6      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1435     | 0.1435     | 0.1435     |   0.0 |  0.03
Output  | 0.0002454  | 0.0002454  | 0.0002454  |   0.0 |  0.00
Modify  | 0.71381    | 0.71381    | 0.71381    |   0.0 |  0.15
Other   |            | 0.09981    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359596 ave      359596 max      359596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359596
Ave neighs/atom = 89.899
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.899235477056, Press = 0.471893784349413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -17516.57      -17516.57      -17658.48      -17658.48       274.53566      274.53566      44110.135      44110.135     -465.3979      -465.3979     
    105000  -17508.581     -17508.581     -17654.347     -17654.347      281.9941       281.9941       44159.418      44159.418     -2018.4563     -2018.4563    
Loop time of 466.786 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.663 hours/ns, 2.142 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 465.82     | 465.82     | 465.82     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14385    | 0.14385    | 0.14385    |   0.0 |  0.03
Output  | 0.00023669 | 0.00023669 | 0.00023669 |   0.0 |  0.00
Modify  | 0.71931    | 0.71931    | 0.71931    |   0.0 |  0.15
Other   |            | 0.1002     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357868 ave      357868 max      357868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357868
Ave neighs/atom = 89.467
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.910607635403, Press = -0.675771298913828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -17508.581     -17508.581     -17654.347     -17654.347      281.9941       281.9941       44159.418      44159.418     -2018.4563     -2018.4563    
    106000  -17518.553     -17518.553     -17658.839     -17658.839      271.3943       271.3943       44049.03       44049.03       1923.9624      1923.9624    
Loop time of 468.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 130.076 hours/ns, 2.135 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 467.3      | 467.3      | 467.3      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.146      | 0.146      | 0.146      |   0.0 |  0.03
Output  | 0.0001925  | 0.0001925  | 0.0001925  |   0.0 |  0.00
Modify  | 0.73151    | 0.73151    | 0.73151    |   0.0 |  0.16
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357842 ave      357842 max      357842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357842
Ave neighs/atom = 89.4605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.92297407119, Press = 0.0688624029675418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -17518.553     -17518.553     -17658.839     -17658.839      271.3943       271.3943       44049.03       44049.03       1923.9624      1923.9624    
    107000  -17512.683     -17512.683     -17655.045     -17655.045      275.40897      275.40897      44124.004      44124.004     -715.13799     -715.13799    
Loop time of 462.597 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.499 hours/ns, 2.162 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 461.64     | 461.64     | 461.64     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14371    | 0.14371    | 0.14371    |   0.0 |  0.03
Output  | 0.00023556 | 0.00023556 | 0.00023556 |   0.0 |  0.00
Modify  | 0.71087    | 0.71087    | 0.71087    |   0.0 |  0.15
Other   |            | 0.09998    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358954 ave      358954 max      358954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358954
Ave neighs/atom = 89.7385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.930600039744, Press = 0.166552518393599
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -17512.683     -17512.683     -17655.045     -17655.045      275.40897      275.40897      44124.004      44124.004     -715.13799     -715.13799    
    108000  -17516.449     -17516.449     -17657.765     -17657.765      273.38686      273.38686      44107.908      44107.908     -361.69998     -361.69998    
Loop time of 462.344 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.429 hours/ns, 2.163 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 461.39     | 461.39     | 461.39     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1426     | 0.1426     | 0.1426     |   0.0 |  0.03
Output  | 0.00019215 | 0.00019215 | 0.00019215 |   0.0 |  0.00
Modify  | 0.71185    | 0.71185    | 0.71185    |   0.0 |  0.15
Other   |            | 0.0998     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357968 ave      357968 max      357968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357968
Ave neighs/atom = 89.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.929723329722, Press = -0.281929944124638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -17516.449     -17516.449     -17657.765     -17657.765      273.38686      273.38686      44107.908      44107.908     -361.69998     -361.69998    
    109000  -17513.269     -17513.269     -17655.506     -17655.506      275.16834      275.16834      44080.407      44080.407      1013.8958      1013.8958    
Loop time of 466.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.538 hours/ns, 2.144 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 465.36     | 465.36     | 465.36     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14523    | 0.14523    | 0.14523    |   0.0 |  0.03
Output  | 0.0001936  | 0.0001936  | 0.0001936  |   0.0 |  0.00
Modify  | 0.7271     | 0.7271     | 0.7271     |   0.0 |  0.16
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358208 ave      358208 max      358208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358208
Ave neighs/atom = 89.552
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.932006336609, Press = 0.133478640154175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -17513.269     -17513.269     -17655.506     -17655.506      275.16834      275.16834      44080.407      44080.407      1013.8958      1013.8958    
    110000  -17519.657     -17519.657     -17658.144     -17658.144      267.9127       267.9127       44158.993      44158.993     -2592.5153     -2592.5153    
Loop time of 459.696 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.693 hours/ns, 2.175 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 458.75     | 458.75     | 458.75     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14279    | 0.14279    | 0.14279    |   0.0 |  0.03
Output  | 0.00024373 | 0.00024373 | 0.00024373 |   0.0 |  0.00
Modify  | 0.70147    | 0.70147    | 0.70147    |   0.0 |  0.15
Other   |            | 0.09885    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359074 ave      359074 max      359074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359074
Ave neighs/atom = 89.7685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.918859213287, Press = 0.186793452861499
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -17519.657     -17519.657     -17658.144     -17658.144      267.9127       267.9127       44158.993      44158.993     -2592.5153     -2592.5153    
    111000  -17514.133     -17514.133     -17655.444     -17655.444      273.3752       273.3752       44086.2        44086.2        757.86063      757.86063    
Loop time of 457.256 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.015 hours/ns, 2.187 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 456.32     | 456.32     | 456.32     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14134    | 0.14134    | 0.14134    |   0.0 |  0.03
Output  | 0.00018893 | 0.00018893 | 0.00018893 |   0.0 |  0.00
Modify  | 0.69572    | 0.69572    | 0.69572    |   0.0 |  0.15
Other   |            | 0.09879    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357120 ave      357120 max      357120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357120
Ave neighs/atom = 89.28
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.917866294857, Press = -0.718597969319949
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -17514.133     -17514.133     -17655.444     -17655.444      273.3752       273.3752       44086.2        44086.2        757.86063      757.86063    
    112000  -17517.252     -17517.252     -17657.719     -17657.719      271.74438      271.74438      44068.437      44068.437      1285.6589      1285.6589    
Loop time of 461.601 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.223 hours/ns, 2.166 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 460.65     | 460.65     | 460.65     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14376    | 0.14376    | 0.14376    |   0.0 |  0.03
Output  | 0.00018852 | 0.00018852 | 0.00018852 |   0.0 |  0.00
Modify  | 0.7054     | 0.7054     | 0.7054     |   0.0 |  0.15
Other   |            | 0.09903    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358744 ave      358744 max      358744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358744
Ave neighs/atom = 89.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.929751195818, Press = 0.394877951020384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -17517.252     -17517.252     -17657.719     -17657.719      271.74438      271.74438      44068.437      44068.437      1285.6589      1285.6589    
    113000  -17515.276     -17515.276     -17654.709     -17654.709      269.74287      269.74287      44138.068      44138.068     -1398.5953     -1398.5953    
Loop time of 477.051 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.181 ns/day, 132.514 hours/ns, 2.096 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 476.06     | 476.06     | 476.06     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14759    | 0.14759    | 0.14759    |   0.0 |  0.03
Output  | 0.00018957 | 0.00018957 | 0.00018957 |   0.0 |  0.00
Modify  | 0.74057    | 0.74057    | 0.74057    |   0.0 |  0.16
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358866 ave      358866 max      358866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358866
Ave neighs/atom = 89.7165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.942856647263, Press = -0.0342114535715722
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -17515.276     -17515.276     -17654.709     -17654.709      269.74287      269.74287      44138.068      44138.068     -1398.5953     -1398.5953    
    114000  -17519.784     -17519.784     -17660.884     -17660.884      272.9667       272.9667       44075.634      44075.634      627.79028      627.79028    
Loop time of 460.416 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.893 hours/ns, 2.172 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 459.47     | 459.47     | 459.47     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14301    | 0.14301    | 0.14301    |   0.0 |  0.03
Output  | 0.00019003 | 0.00019003 | 0.00019003 |   0.0 |  0.00
Modify  | 0.70406    | 0.70406    | 0.70406    |   0.0 |  0.15
Other   |            | 0.09886    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358352 ave      358352 max      358352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358352
Ave neighs/atom = 89.588
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.941312009377, Press = -0.196441131389489
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -17519.784     -17519.784     -17660.884     -17660.884      272.9667       272.9667       44075.634      44075.634      627.79028      627.79028    
    115000  -17513.52      -17513.52      -17657.117     -17657.117      277.79955      277.79955      44100.353      44100.353      45.121741      45.121741    
Loop time of 466.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.547 hours/ns, 2.144 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 465.41     | 465.41     | 465.41     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14557    | 0.14557    | 0.14557    |   0.0 |  0.03
Output  | 0.00018959 | 0.00018959 | 0.00018959 |   0.0 |  0.00
Modify  | 0.71726    | 0.71726    | 0.71726    |   0.0 |  0.15
Other   |            | 0.09864    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358574 ave      358574 max      358574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358574
Ave neighs/atom = 89.6435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.931378303298, Press = 0.180734795514799
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -17513.52      -17513.52      -17657.117     -17657.117      277.79955      277.79955      44100.353      44100.353      45.121741      45.121741    
    116000  -17521.651     -17521.651     -17657.439     -17657.439      262.69082      262.69082      44117.767      44117.767     -906.28607     -906.28607    
Loop time of 465.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.269 hours/ns, 2.149 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 464.4      | 464.4      | 464.4      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14442    | 0.14442    | 0.14442    |   0.0 |  0.03
Output  | 0.00024232 | 0.00024232 | 0.00024232 |   0.0 |  0.00
Modify  | 0.71928    | 0.71928    | 0.71928    |   0.0 |  0.15
Other   |            | 0.1005     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358198 ave      358198 max      358198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358198
Ave neighs/atom = 89.5495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.92162275779, Press = -0.162741532049704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -17521.651     -17521.651     -17657.439     -17657.439      262.69082      262.69082      44117.767      44117.767     -906.28607     -906.28607    
    117000  -17515.506     -17515.506     -17656.745     -17656.745      273.23552      273.23552      44050.595      44050.595      2135.0053      2135.0053    
Loop time of 464.655 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.071 hours/ns, 2.152 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 463.69     | 463.69     | 463.69     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14408    | 0.14408    | 0.14408    |   0.0 |  0.03
Output  | 0.00024469 | 0.00024469 | 0.00024469 |   0.0 |  0.00
Modify  | 0.71901    | 0.71901    | 0.71901    |   0.0 |  0.15
Other   |            | 0.1        |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358184 ave      358184 max      358184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358184
Ave neighs/atom = 89.546
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.91411426062, Press = -0.205424763465383
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -17515.506     -17515.506     -17656.745     -17656.745      273.23552      273.23552      44050.595      44050.595      2135.0053      2135.0053    
    118000  -17516.937     -17516.937     -17656.706     -17656.706      270.39215      270.39215      44106.6        44106.6       -332.22863     -332.22863    
Loop time of 458.56 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.378 hours/ns, 2.181 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 457.62     | 457.62     | 457.62     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14149    | 0.14149    | 0.14149    |   0.0 |  0.03
Output  | 0.00019468 | 0.00019468 | 0.00019468 |   0.0 |  0.00
Modify  | 0.69757    | 0.69757    | 0.69757    |   0.0 |  0.15
Other   |            | 0.09951    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359410 ave      359410 max      359410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359410
Ave neighs/atom = 89.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 = 272.900430110618, Press = 0.653083766561064
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -17516.937     -17516.937     -17656.706     -17656.706      270.39215      270.39215      44106.6        44106.6       -332.22863     -332.22863    
    119000  -17519.506     -17519.506     -17657.916     -17657.916      267.76317      267.76317      44122.278      44122.278     -1118.3647     -1118.3647    
Loop time of 461.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.259 hours/ns, 2.166 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 460.78     | 460.78     | 460.78     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14224    | 0.14224    | 0.14224    |   0.0 |  0.03
Output  | 0.00019093 | 0.00019093 | 0.00019093 |   0.0 |  0.00
Modify  | 0.70817    | 0.70817    | 0.70817    |   0.0 |  0.15
Other   |            | 0.09974    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358654 ave      358654 max      358654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358654
Ave neighs/atom = 89.6635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.902182317297, Press = -0.165493028808511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -17519.506     -17519.506     -17657.916     -17657.916      267.76317      267.76317      44122.278      44122.278     -1118.3647     -1118.3647    
    120000  -17514.734     -17514.734     -17655.861     -17655.861      273.0186       273.0186       44077.627      44077.627      1031.4625      1031.4625    
Loop time of 466.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.492 hours/ns, 2.145 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 465.21     | 465.21     | 465.21     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1445     | 0.1445     | 0.1445     |   0.0 |  0.03
Output  | 0.00019173 | 0.00019173 | 0.00019173 |   0.0 |  0.00
Modify  | 0.71828    | 0.71828    | 0.71828    |   0.0 |  0.15
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358110 ave      358110 max      358110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358110
Ave neighs/atom = 89.5275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.897948504133, Press = -0.0333559114607827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -17514.734     -17514.734     -17655.861     -17655.861      273.0186       273.0186       44077.627      44077.627      1031.4625      1031.4625    
    121000  -17516.332     -17516.332     -17656.636     -17656.636      271.42788      271.42788      44114.089      44114.089     -606.68602     -606.68602    
Loop time of 468.538 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.149 hours/ns, 2.134 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 467.56     | 467.56     | 467.56     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14613    | 0.14613    | 0.14613    |   0.0 |  0.03
Output  | 0.0001898  | 0.0001898  | 0.0001898  |   0.0 |  0.00
Modify  | 0.72927    | 0.72927    | 0.72927    |   0.0 |  0.16
Other   |            | 0.1007     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359142 ave      359142 max      359142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359142
Ave neighs/atom = 89.7855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.885151096719, Press = 0.184802259300897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -17516.332     -17516.332     -17656.636     -17656.636      271.42788      271.42788      44114.089      44114.089     -606.68602     -606.68602    
    122000  -17518.732     -17518.732     -17657.207     -17657.207      267.88903      267.88903      44111.089      44111.089     -595.99736     -595.99736    
Loop time of 472.702 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.183 ns/day, 131.306 hours/ns, 2.115 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 471.71     | 471.71     | 471.71     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14743    | 0.14743    | 0.14743    |   0.0 |  0.03
Output  | 0.00026877 | 0.00026877 | 0.00026877 |   0.0 |  0.00
Modify  | 0.73749    | 0.73749    | 0.73749    |   0.0 |  0.16
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358346 ave      358346 max      358346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358346
Ave neighs/atom = 89.5865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.880624965016, Press = -0.358199392123072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -17518.732     -17518.732     -17657.207     -17657.207      267.88903      267.88903      44111.089      44111.089     -595.99736     -595.99736    
    123000  -17513.789     -17513.789     -17657.172     -17657.172      277.38496      277.38496      44057.431      44057.431      1806.3465      1806.3465    
Loop time of 470.794 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.776 hours/ns, 2.124 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 469.81     | 469.81     | 469.81     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14538    | 0.14538    | 0.14538    |   0.0 |  0.03
Output  | 0.00019408 | 0.00019408 | 0.00019408 |   0.0 |  0.00
Modify  | 0.7323     | 0.7323     | 0.7323     |   0.0 |  0.16
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358352 ave      358352 max      358352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358352
Ave neighs/atom = 89.588
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.876904230182, Press = 0.0960471891760862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -17513.789     -17513.789     -17657.172     -17657.172      277.38496      277.38496      44057.431      44057.431      1806.3465      1806.3465    
    124000  -17515.557     -17515.557     -17656.883     -17656.883      273.40381      273.40381      44132.675      44132.675     -1289.4959     -1289.4959    
Loop time of 462.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.352 hours/ns, 2.164 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 461.11     | 461.11     | 461.11     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14296    | 0.14296    | 0.14296    |   0.0 |  0.03
Output  | 0.00025071 | 0.00025071 | 0.00025071 |   0.0 |  0.00
Modify  | 0.71501    | 0.71501    | 0.71501    |   0.0 |  0.15
Other   |            | 0.09988    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       359202 ave      359202 max      359202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 359202
Ave neighs/atom = 89.8005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.881011842194, Press = 0.211713023001394
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -17515.557     -17515.557     -17656.883     -17656.883      273.40381      273.40381      44132.675      44132.675     -1289.4959     -1289.4959    
    125000  -17517.251     -17517.251     -17658.281     -17658.281      272.8327       272.8327       44086.552      44086.552      436.77002      436.77002    
Loop time of 468.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.112 hours/ns, 2.135 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 467.43     | 467.43     | 467.43     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14434    | 0.14434    | 0.14434    |   0.0 |  0.03
Output  | 0.00020234 | 0.00020234 | 0.00020234 |   0.0 |  0.00
Modify  | 0.73085    | 0.73085    | 0.73085    |   0.0 |  0.16
Other   |            | 0.1008     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357760 ave      357760 max      357760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357760
Ave neighs/atom = 89.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.900049329137, Press = -0.379337724882069
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -17517.251     -17517.251     -17658.281     -17658.281      272.8327       272.8327       44086.552      44086.552      436.77002      436.77002    
    126000  -17511.982     -17511.982     -17657.595     -17657.595      281.69822      281.69822      44079.625      44079.625      873.75661      873.75661    
Loop time of 457.669 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.130 hours/ns, 2.185 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 456.72     | 456.72     | 456.72     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14249    | 0.14249    | 0.14249    |   0.0 |  0.03
Output  | 0.00019095 | 0.00019095 | 0.00019095 |   0.0 |  0.00
Modify  | 0.70281    | 0.70281    | 0.70281    |   0.0 |  0.15
Other   |            | 0.09909    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358434 ave      358434 max      358434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358434
Ave neighs/atom = 89.6085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.907791811467, Press = 0.321691200504787
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -17511.982     -17511.982     -17657.595     -17657.595      281.69822      281.69822      44079.625      44079.625      873.75661      873.75661    
    127000  -17517.858     -17517.858     -17657.879     -17657.879      270.88186      270.88186      44121.66       44121.66      -1036.4556     -1036.4556    
Loop time of 459.524 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.646 hours/ns, 2.176 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 458.58     | 458.58     | 458.58     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14308    | 0.14308    | 0.14308    |   0.0 |  0.03
Output  | 0.00018967 | 0.00018967 | 0.00018967 |   0.0 |  0.00
Modify  | 0.70463    | 0.70463    | 0.70463    |   0.0 |  0.15
Other   |            | 0.09936    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358714 ave      358714 max      358714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358714
Ave neighs/atom = 89.6785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.91726719758, Press = 0.00937771018961956
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -17517.858     -17517.858     -17657.879     -17657.879      270.88186      270.88186      44121.66       44121.66      -1036.4556     -1036.4556    
    128000  -17512.618     -17512.618     -17653.548     -17653.548      272.63927      272.63927      44101.914      44101.914      275.85887      275.85887    
Loop time of 463.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 128.858 hours/ns, 2.156 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 462.93     | 462.93     | 462.93     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14306    | 0.14306    | 0.14306    |   0.0 |  0.03
Output  | 0.0001924  | 0.0001924  | 0.0001924  |   0.0 |  0.00
Modify  | 0.71412    | 0.71412    | 0.71412    |   0.0 |  0.15
Other   |            | 0.1002     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357828 ave      357828 max      357828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357828
Ave neighs/atom = 89.457
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.932941438195, Press = -0.0710661408902034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -17512.618     -17512.618     -17653.548     -17653.548      272.63927      272.63927      44101.914      44101.914      275.85887      275.85887    
    129000  -17516.941     -17516.941     -17656.608     -17656.608      270.19501      270.19501      44093.041      44093.041      351.31874      351.31874    
Loop time of 466.126 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.479 hours/ns, 2.145 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 465.16     | 465.16     | 465.16     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14545    | 0.14545    | 0.14545    |   0.0 |  0.03
Output  | 0.00019215 | 0.00019215 | 0.00019215 |   0.0 |  0.00
Modify  | 0.71999    | 0.71999    | 0.71999    |   0.0 |  0.15
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358958 ave      358958 max      358958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358958
Ave neighs/atom = 89.7395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.948639837996, Press = 0.0599052966369531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -17516.941     -17516.941     -17656.608     -17656.608      270.19501      270.19501      44093.041      44093.041      351.31874      351.31874    
    130000  -17512.556     -17512.556     -17654.851     -17654.851      275.27911      275.27911      44122.831      44122.831     -629.50131     -629.50131    
Loop time of 462.599 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.500 hours/ns, 2.162 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 461.64     | 461.64     | 461.64     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14409    | 0.14409    | 0.14409    |   0.0 |  0.03
Output  | 0.00018952 | 0.00018952 | 0.00018952 |   0.0 |  0.00
Modify  | 0.71288    | 0.71288    | 0.71288    |   0.0 |  0.15
Other   |            | 0.1002     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358760 ave      358760 max      358760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358760
Ave neighs/atom = 89.69
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
44100.3526813562

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0