# 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.613315641880036*${_u_distance}
variable latticeconst_converted equal 3.613315641880036*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331564188004
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133156 36.133156 36.133156)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (36.133156 36.133156 36.133156)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6294254851 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 253.15*${_u_temperature}
variable temp_converted equal 253.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 253.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "253.15 - 0.2"
variable      T_up  equal  "253.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_849011491644_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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14029.144     -14029.144     -14160         -14160          253.15         253.15         47175.629      47175.629      2962.7532      2962.7532    
      1000  -13891.154     -13891.154     -14025.485     -14025.485      259.87077      259.87077      47819.315      47819.315      442.31513      442.31513    
Loop time of 163.687 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.528 ns/day, 45.469 hours/ns, 6.109 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 162.75     | 162.75     | 162.75     |   0.0 | 99.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1494     | 0.1494     | 0.1494     |   0.0 |  0.09
Output  | 0.00024065 | 0.00024065 | 0.00024065 |   0.0 |  0.00
Modify  | 0.68332    | 0.68332    | 0.68332    |   0.0 |  0.42
Other   |            | 0.09945    |            |       |  0.06

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:       216000 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13891.154     -13891.154     -14025.485     -14025.485      259.87077      259.87077      47819.315      47819.315      442.31513      442.31513    
      2000  -13900.169     -13900.169     -14032.673     -14032.673      256.33861      256.33861      47811.972      47811.972     -61.728756     -61.728756    
Loop time of 175.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.491 ns/day, 48.860 hours/ns, 5.685 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.02     | 175.02     | 175.02     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14098    | 0.14098    | 0.14098    |   0.0 |  0.08
Output  | 0.0002306  | 0.0002306  | 0.0002306  |   0.0 |  0.00
Modify  | 0.63917    | 0.63917    | 0.63917    |   0.0 |  0.36
Other   |            | 0.09648    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       249250 ave      249250 max      249250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.468 ns/day, 51.306 hours/ns, 5.414 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 183.77     | 183.77     | 183.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14991    | 0.14991    | 0.14991    |   0.0 |  0.08
Output  | 0.0002316  | 0.0002316  | 0.0002316  |   0.0 |  0.00
Modify  | 0.68639    | 0.68639    | 0.68639    |   0.0 |  0.37
Other   |            | 0.09823    |            |       |  0.05

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:       248858 ave      248858 max      248858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.488 ns/day, 49.157 hours/ns, 5.651 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.09     | 176.09     | 176.09     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14485    | 0.14485    | 0.14485    |   0.0 |  0.08
Output  | 0.0002354  | 0.0002354  | 0.0002354  |   0.0 |  0.00
Modify  | 0.64146    | 0.64146    | 0.64146    |   0.0 |  0.36
Other   |            | 0.09482    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248676 ave      248676 max      248676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248676
Ave neighs/atom = 62.169
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13897.892     -13897.892     -14028.238     -14028.238      252.16278      252.16278      47854.41       47854.41      -787.92381     -787.92381    
      5000  -13900.495     -13900.495     -14027.377     -14027.377      245.46265      245.46265      47857.258      47857.258     -765.09366     -765.09366    
Loop time of 176.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.488 ns/day, 49.158 hours/ns, 5.651 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.08     | 176.08     | 176.08     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14452    | 0.14452    | 0.14452    |   0.0 |  0.08
Output  | 0.00019192 | 0.00019192 | 0.00019192 |   0.0 |  0.00
Modify  | 0.64613    | 0.64613    | 0.64613    |   0.0 |  0.37
Other   |            | 0.094      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248680 ave      248680 max      248680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248680
Ave neighs/atom = 62.17
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.404964642176, Press = -50.0285102821197
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13900.495     -13900.495     -14027.377     -14027.377      245.46265      245.46265      47857.258      47857.258     -765.09366     -765.09366    
      6000  -13895.302     -13895.302     -14030.37      -14030.37       261.29721      261.29721      47874.139      47874.139     -1380.0524     -1380.0524    
Loop time of 189.944 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.762 hours/ns, 5.265 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.95     | 188.95     | 188.95     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15415    | 0.15415    | 0.15415    |   0.0 |  0.08
Output  | 0.00019332 | 0.00019332 | 0.00019332 |   0.0 |  0.00
Modify  | 0.74316    | 0.74316    | 0.74316    |   0.0 |  0.39
Other   |            | 0.1005     |            |       |  0.05

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:       248432 ave      248432 max      248432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248432
Ave neighs/atom = 62.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.675427040044, Press = 10.9561326193758
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13895.302     -13895.302     -14030.37      -14030.37       261.29721      261.29721      47874.139      47874.139     -1380.0524     -1380.0524    
      7000  -13900.818     -13900.818     -14030.162     -14030.162      250.22521      250.22521      47860.016      47860.016     -1100.7327     -1100.7327    
Loop time of 176.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.489 ns/day, 49.130 hours/ns, 5.654 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.96     | 175.96     | 175.96     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14505    | 0.14505    | 0.14505    |   0.0 |  0.08
Output  | 0.000236   | 0.000236   | 0.000236   |   0.0 |  0.00
Modify  | 0.66811    | 0.66811    | 0.66811    |   0.0 |  0.38
Other   |            | 0.09483    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       247876 ave      247876 max      247876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247876
Ave neighs/atom = 61.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.062926440514, Press = 8.16225318298536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13900.818     -13900.818     -14030.162     -14030.162      250.22521      250.22521      47860.016      47860.016     -1100.7327     -1100.7327    
      8000  -13899.619     -13899.619     -14028.371     -14028.371      249.08023      249.08023      47857.003      47857.003     -844.14076     -844.14076    
Loop time of 206.166 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.268 hours/ns, 4.850 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.06     | 205.06     | 205.06     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16445    | 0.16445    | 0.16445    |   0.0 |  0.08
Output  | 0.00019283 | 0.00019283 | 0.00019283 |   0.0 |  0.00
Modify  | 0.83279    | 0.83279    | 0.83279    |   0.0 |  0.40
Other   |            | 0.1081     |            |       |  0.05

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:       248296 ave      248296 max      248296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248296
Ave neighs/atom = 62.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.076891944129, Press = 9.7157804816905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13899.619     -13899.619     -14028.371     -14028.371      249.08023      249.08023      47857.003      47857.003     -844.14076     -844.14076    
      9000  -13894.193     -13894.193     -14025.313     -14025.313      253.66064      253.66064      47851.931      47851.931     -210.6159      -210.6159     
Loop time of 206.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.422 hours/ns, 4.837 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.61     | 205.61     | 205.61     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16421    | 0.16421    | 0.16421    |   0.0 |  0.08
Output  | 0.00023578 | 0.00023578 | 0.00023578 |   0.0 |  0.00
Modify  | 0.83669    | 0.83669    | 0.83669    |   0.0 |  0.40
Other   |            | 0.1083     |            |       |  0.05

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:       248402 ave      248402 max      248402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248402
Ave neighs/atom = 62.1005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.342493907335, Press = 8.70241731930785
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13894.193     -13894.193     -14025.313     -14025.313      253.66064      253.66064      47851.931      47851.931     -210.6159      -210.6159     
     10000  -13896.962     -13896.962     -14026.68      -14026.68       250.94912      250.94912      47840.66       47840.66      -155.94223     -155.94223    
Loop time of 206.731 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.425 hours/ns, 4.837 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.62     | 205.62     | 205.62     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16397    | 0.16397    | 0.16397    |   0.0 |  0.08
Output  | 0.00019147 | 0.00019147 | 0.00019147 |   0.0 |  0.00
Modify  | 0.84032    | 0.84032    | 0.84032    |   0.0 |  0.41
Other   |            | 0.1083     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248658 ave      248658 max      248658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248658
Ave neighs/atom = 62.1645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.253097214102, Press = 8.98708496586452
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13896.962     -13896.962     -14026.68      -14026.68       250.94912      250.94912      47840.66       47840.66      -155.94223     -155.94223    
     11000  -13900.07      -13900.07      -14029.121     -14029.121      249.65846      249.65846      47811.119      47811.119      347.91507      347.91507    
Loop time of 206.07 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.242 hours/ns, 4.853 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.97     | 204.97     | 204.97     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16492    | 0.16492    | 0.16492    |   0.0 |  0.08
Output  | 0.0001916  | 0.0001916  | 0.0001916  |   0.0 |  0.00
Modify  | 0.83055    | 0.83055    | 0.83055    |   0.0 |  0.40
Other   |            | 0.1082     |            |       |  0.05

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:       248808 ave      248808 max      248808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248808
Ave neighs/atom = 62.202
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.050301903312, Press = 3.79463382151427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13900.07      -13900.07      -14029.121     -14029.121      249.65846      249.65846      47811.119      47811.119      347.91507      347.91507    
     12000  -13894.356     -13894.356     -14027.856     -14027.856      258.26515      258.26515      47817.165      47817.165      554.51753      554.51753    
Loop time of 201.667 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.019 hours/ns, 4.959 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.58     | 200.58     | 200.58     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16355    | 0.16355    | 0.16355    |   0.0 |  0.08
Output  | 0.00025138 | 0.00025138 | 0.00025138 |   0.0 |  0.00
Modify  | 0.81846    | 0.81846    | 0.81846    |   0.0 |  0.41
Other   |            | 0.1066     |            |       |  0.05

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:       248940 ave      248940 max      248940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248940
Ave neighs/atom = 62.235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.121100217379, Press = 2.24810535576076
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13894.356     -13894.356     -14027.856     -14027.856      258.26515      258.26515      47817.165      47817.165      554.51753      554.51753    
     13000  -13899.102     -13899.102     -14029.904     -14029.904      253.04455      253.04455      47778.245      47778.245      1272.6692      1272.6692    
Loop time of 198.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.123 hours/ns, 5.039 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.38     | 197.38     | 197.38     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15979    | 0.15979    | 0.15979    |   0.0 |  0.08
Output  | 0.00019066 | 0.00019066 | 0.00019066 |   0.0 |  0.00
Modify  | 0.79596    | 0.79596    | 0.79596    |   0.0 |  0.40
Other   |            | 0.1053     |            |       |  0.05

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:       248604 ave      248604 max      248604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248604
Ave neighs/atom = 62.151
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.199221595618, Press = 1.40322254891724
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13899.102     -13899.102     -14029.904     -14029.904      253.04455      253.04455      47778.245      47778.245      1272.6692      1272.6692    
     14000  -13897.677     -13897.677     -14027.659     -14027.659      251.45892      251.45892      47769.826      47769.826      1708.336       1708.336     
Loop time of 177.269 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.487 ns/day, 49.241 hours/ns, 5.641 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.36     | 176.36     | 176.36     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1466     | 0.1466     | 0.1466     |   0.0 |  0.08
Output  | 0.00019854 | 0.00019854 | 0.00019854 |   0.0 |  0.00
Modify  | 0.67189    | 0.67189    | 0.67189    |   0.0 |  0.38
Other   |            | 0.09496    |            |       |  0.05

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:       249436 ave      249436 max      249436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249436
Ave neighs/atom = 62.359
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.407295218345, Press = -0.956037812069403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13897.677     -13897.677     -14027.659     -14027.659      251.45892      251.45892      47769.826      47769.826      1708.336       1708.336     
     15000  -13898.711     -13898.711     -14029.579     -14029.579      253.17327      253.17327      47774.288      47774.288      1492.7833      1492.7833    
Loop time of 176.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.489 ns/day, 49.129 hours/ns, 5.654 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.95     | 175.95     | 175.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14352    | 0.14352    | 0.14352    |   0.0 |  0.08
Output  | 0.00019138 | 0.00019138 | 0.00019138 |   0.0 |  0.00
Modify  | 0.67083    | 0.67083    | 0.67083    |   0.0 |  0.38
Other   |            | 0.09628    |            |       |  0.05

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:       249708 ave      249708 max      249708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249708
Ave neighs/atom = 62.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.362240374586, Press = -1.73354509840595
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13898.711     -13898.711     -14029.579     -14029.579      253.17327      253.17327      47774.288      47774.288      1492.7833      1492.7833    
     16000  -13897.931     -13897.931     -14029.162     -14029.162      253.87659      253.87659      47801.39       47801.39       713.16232      713.16232    
Loop time of 190.535 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.453 ns/day, 52.926 hours/ns, 5.248 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 189.53     | 189.53     | 189.53     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15485    | 0.15485    | 0.15485    |   0.0 |  0.08
Output  | 0.00019497 | 0.00019497 | 0.00019497 |   0.0 |  0.00
Modify  | 0.74885    | 0.74885    | 0.74885    |   0.0 |  0.39
Other   |            | 0.1016     |            |       |  0.05

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:       249638 ave      249638 max      249638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249638
Ave neighs/atom = 62.4095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.356513836829, Press = -2.66221821105308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13897.931     -13897.931     -14029.162     -14029.162      253.87659      253.87659      47801.39       47801.39       713.16232      713.16232    
     17000  -13900.897     -13900.897     -14028.274     -14028.274      246.4204       246.4204       47820.92       47820.92       210.97267      210.97267    
Loop time of 206.861 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.461 hours/ns, 4.834 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.75     | 205.75     | 205.75     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16551    | 0.16551    | 0.16551    |   0.0 |  0.08
Output  | 0.0001931  | 0.0001931  | 0.0001931  |   0.0 |  0.00
Modify  | 0.83941    | 0.83941    | 0.83941    |   0.0 |  0.41
Other   |            | 0.1084     |            |       |  0.05

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:       249082 ave      249082 max      249082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249082
Ave neighs/atom = 62.2705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.3449200935, Press = -1.47550920420547
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13900.897     -13900.897     -14028.274     -14028.274      246.4204       246.4204       47820.92       47820.92       210.97267      210.97267    
     18000  -13898.668     -13898.668     -14028.974     -14028.974      252.08494      252.08494      47834.119      47834.119     -220.37949     -220.37949    
Loop time of 207.173 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.548 hours/ns, 4.827 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.06     | 206.06     | 206.06     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16463    | 0.16463    | 0.16463    |   0.0 |  0.08
Output  | 0.00019025 | 0.00019025 | 0.00019025 |   0.0 |  0.00
Modify  | 0.84083    | 0.84083    | 0.84083    |   0.0 |  0.41
Other   |            | 0.1087     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248718 ave      248718 max      248718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248718
Ave neighs/atom = 62.1795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.363012908728, Press = -0.476437959431139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13898.668     -13898.668     -14028.974     -14028.974      252.08494      252.08494      47834.119      47834.119     -220.37949     -220.37949    
     19000  -13898.54      -13898.54      -14026.558     -14026.558      247.66104      247.66104      47827          47827          208.65871      208.65871    
Loop time of 199.388 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.386 hours/ns, 5.015 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.33     | 198.33     | 198.33     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15996    | 0.15996    | 0.15996    |   0.0 |  0.08
Output  | 0.00024715 | 0.00024715 | 0.00024715 |   0.0 |  0.00
Modify  | 0.79603    | 0.79603    | 0.79603    |   0.0 |  0.40
Other   |            | 0.1063     |            |       |  0.05

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:       248694 ave      248694 max      248694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248694
Ave neighs/atom = 62.1735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.295566358647, Press = 0.652293706539266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13898.54      -13898.54      -14026.558     -14026.558      247.66104      247.66104      47827          47827          208.65871      208.65871    
     20000  -13897.311     -13897.311     -14027.746     -14027.746      252.33465      252.33465      47835.5        47835.5       -112.0763      -112.0763     
Loop time of 208.036 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.788 hours/ns, 4.807 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.92     | 206.92     | 206.92     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16556    | 0.16556    | 0.16556    |   0.0 |  0.08
Output  | 0.00030814 | 0.00030814 | 0.00030814 |   0.0 |  0.00
Modify  | 0.84281    | 0.84281    | 0.84281    |   0.0 |  0.41
Other   |            | 0.1079     |            |       |  0.05

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:       248688 ave      248688 max      248688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248688
Ave neighs/atom = 62.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.258418090781, Press = 0.699430133114411
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13897.311     -13897.311     -14027.746     -14027.746      252.33465      252.33465      47835.5        47835.5       -112.0763      -112.0763     
     21000  -13900.263     -13900.263     -14029.287     -14029.287      249.60611      249.60611      47800.677      47800.677      713.47606      713.47606    
Loop time of 203.213 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.448 hours/ns, 4.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.11     | 202.11     | 202.11     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1643     | 0.1643     | 0.1643     |   0.0 |  0.08
Output  | 0.00019212 | 0.00019212 | 0.00019212 |   0.0 |  0.00
Modify  | 0.82771    | 0.82771    | 0.82771    |   0.0 |  0.41
Other   |            | 0.1069     |            |       |  0.05

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:       248536 ave      248536 max      248536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248536
Ave neighs/atom = 62.134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.28692433105, Press = 0.955244565835294
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13900.263     -13900.263     -14029.287     -14029.287      249.60611      249.60611      47800.677      47800.677      713.47606      713.47606    
     22000  -13895.804     -13895.804     -14028.28      -14028.28       256.28438      256.28438      47788.002      47788.002      1252.3411      1252.3411    
Loop time of 207.345 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.596 hours/ns, 4.823 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.23     | 206.23     | 206.23     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16688    | 0.16688    | 0.16688    |   0.0 |  0.08
Output  | 0.00023149 | 0.00023149 | 0.00023149 |   0.0 |  0.00
Modify  | 0.84133    | 0.84133    | 0.84133    |   0.0 |  0.41
Other   |            | 0.1097     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       249282 ave      249282 max      249282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249282
Ave neighs/atom = 62.3205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.344173005738, Press = 0.481695918565459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13895.804     -13895.804     -14028.28      -14028.28       256.28438      256.28438      47788.002      47788.002      1252.3411      1252.3411    
     23000  -13897.624     -13897.624     -14029.152     -14029.152      254.44952      254.44952      47780.151      47780.151      1324.4685      1324.4685    
Loop time of 202.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.352 hours/ns, 4.929 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.78     | 201.78     | 201.78     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16143    | 0.16143    | 0.16143    |   0.0 |  0.08
Output  | 0.00025252 | 0.00025252 | 0.00025252 |   0.0 |  0.00
Modify  | 0.81345    | 0.81345    | 0.81345    |   0.0 |  0.40
Other   |            | 0.107      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       249446 ave      249446 max      249446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249446
Ave neighs/atom = 62.3615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.342350445789, Press = 0.257222282922906
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13897.624     -13897.624     -14029.152     -14029.152      254.44952      254.44952      47780.151      47780.151      1324.4685      1324.4685    
     24000  -13898.934     -13898.934     -14031.361     -14031.361      256.18889      256.18889      47781.192      47781.192      1050.2776      1050.2776    
Loop time of 194.522 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.034 hours/ns, 5.141 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.49     | 193.49     | 193.49     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15778    | 0.15778    | 0.15778    |   0.0 |  0.08
Output  | 0.00019475 | 0.00019475 | 0.00019475 |   0.0 |  0.00
Modify  | 0.76811    | 0.76811    | 0.76811    |   0.0 |  0.39
Other   |            | 0.1032     |            |       |  0.05

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:       249404 ave      249404 max      249404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249404
Ave neighs/atom = 62.351
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.40681958891, Press = -0.859606779858275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13898.934     -13898.934     -14031.361     -14031.361      256.18889      256.18889      47781.192      47781.192      1050.2776      1050.2776    
     25000  -13899.618     -13899.618     -14029.698     -14029.698      251.6487       251.6487       47768.82       47768.82       1652.3378      1652.3378    
Loop time of 177.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.487 ns/day, 49.269 hours/ns, 5.638 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.45     | 176.45     | 176.45     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14712    | 0.14712    | 0.14712    |   0.0 |  0.08
Output  | 0.00019302 | 0.00019302 | 0.00019302 |   0.0 |  0.00
Modify  | 0.67329    | 0.67329    | 0.67329    |   0.0 |  0.38
Other   |            | 0.09526    |            |       |  0.05

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:       249140 ave      249140 max      249140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249140
Ave neighs/atom = 62.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 = 253.432323313037, Press = -2.554743817224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13899.618     -13899.618     -14029.698     -14029.698      251.6487       251.6487       47768.82       47768.82       1652.3378      1652.3378    
     26000  -13896.243     -13896.243     -14028.189     -14028.189      255.25917      255.25917      47818.438      47818.438      266.1682       266.1682     
Loop time of 194.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.950 hours/ns, 5.149 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.19     | 193.19     | 193.19     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15818    | 0.15818    | 0.15818    |   0.0 |  0.08
Output  | 0.00019604 | 0.00019604 | 0.00019604 |   0.0 |  0.00
Modify  | 0.77012    | 0.77012    | 0.77012    |   0.0 |  0.40
Other   |            | 0.1027     |            |       |  0.05

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:       249628 ave      249628 max      249628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249628
Ave neighs/atom = 62.407
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.451866570181, Press = -2.76665191461382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13896.243     -13896.243     -14028.189     -14028.189      255.25917      255.25917      47818.438      47818.438      266.1682       266.1682     
     27000  -13896.343     -13896.343     -14029.431     -14029.431      257.4671       257.4671       47841.112      47841.112     -413.1292      -413.1292     
Loop time of 206.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.477 hours/ns, 4.833 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.8      | 205.8      | 205.8      |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16519    | 0.16519    | 0.16519    |   0.0 |  0.08
Output  | 0.00019457 | 0.00019457 | 0.00019457 |   0.0 |  0.00
Modify  | 0.83788    | 0.83788    | 0.83788    |   0.0 |  0.40
Other   |            | 0.1088     |            |       |  0.05

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:       249118 ave      249118 max      249118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249118
Ave neighs/atom = 62.2795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.426832932512, Press = -0.592640170479227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13896.343     -13896.343     -14029.431     -14029.431      257.4671       257.4671       47841.112      47841.112     -413.1292      -413.1292     
     28000  -13899.379     -13899.379     -14028.442     -14028.442      249.68106      249.68106      47842.248      47842.248     -413.90702     -413.90702    
Loop time of 206.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.455 hours/ns, 4.835 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.72     | 205.72     | 205.72     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16579    | 0.16579    | 0.16579    |   0.0 |  0.08
Output  | 0.00019245 | 0.00019245 | 0.00019245 |   0.0 |  0.00
Modify  | 0.84115    | 0.84115    | 0.84115    |   0.0 |  0.41
Other   |            | 0.1082     |            |       |  0.05

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:       248324 ave      248324 max      248324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248324
Ave neighs/atom = 62.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.473254146921, Press = -0.0919635524528976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13899.379     -13899.379     -14028.442     -14028.442      249.68106      249.68106      47842.248      47842.248     -413.90702     -413.90702    
     29000  -13895.206     -13895.206     -14026.277     -14026.277      253.56546      253.56546      47882.245      47882.245     -1373.156      -1373.156     
Loop time of 204.947 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.930 hours/ns, 4.879 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.85     | 203.85     | 203.85     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16133    | 0.16133    | 0.16133    |   0.0 |  0.08
Output  | 0.00019148 | 0.00019148 | 0.00019148 |   0.0 |  0.00
Modify  | 0.82836    | 0.82836    | 0.82836    |   0.0 |  0.40
Other   |            | 0.1056     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248478 ave      248478 max      248478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248478
Ave neighs/atom = 62.1195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.518310284666, Press = 1.15737715558908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13895.206     -13895.206     -14026.277     -14026.277      253.56546      253.56546      47882.245      47882.245     -1373.156      -1373.156     
     30000  -13900.931     -13900.931     -14030.641     -14030.641      250.93358      250.93358      47866.881      47866.881     -1395.672      -1395.672     
Loop time of 205.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.217 hours/ns, 4.855 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.88     | 204.88     | 204.88     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16244    | 0.16244    | 0.16244    |   0.0 |  0.08
Output  | 0.00019279 | 0.00019279 | 0.00019279 |   0.0 |  0.00
Modify  | 0.83478    | 0.83478    | 0.83478    |   0.0 |  0.41
Other   |            | 0.106      |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5837 ave        5837 max        5837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248024 ave      248024 max      248024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248024
Ave neighs/atom = 62.006
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.484581743926, Press = 2.2064346244579
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13900.931     -13900.931     -14030.641     -14030.641      250.93358      250.93358      47866.881      47866.881     -1395.672      -1395.672     
     31000  -13897.12      -13897.12      -14027.53      -14027.53       252.28797      252.28797      47823.642      47823.642      139.72765      139.72765    
Loop time of 189.118 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.457 ns/day, 52.533 hours/ns, 5.288 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.12     | 188.12     | 188.12     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15393    | 0.15393    | 0.15393    |   0.0 |  0.08
Output  | 0.00019452 | 0.00019452 | 0.00019452 |   0.0 |  0.00
Modify  | 0.74217    | 0.74217    | 0.74217    |   0.0 |  0.39
Other   |            | 0.0992     |            |       |  0.05

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:       247978 ave      247978 max      247978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 247978
Ave neighs/atom = 61.9945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.470457353155, Press = 0.85596703812929
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13897.12      -13897.12      -14027.53      -14027.53       252.28797      252.28797      47823.642      47823.642      139.72765      139.72765    
     32000  -13897.996     -13897.996     -14031.73      -14031.73       258.71737      258.71737      47833.345      47833.345     -455.27608     -455.27608    
Loop time of 184.716 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.310 hours/ns, 5.414 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 183.75     | 183.75     | 183.75     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14955    | 0.14955    | 0.14955    |   0.0 |  0.08
Output  | 0.00026814 | 0.00026814 | 0.00026814 |   0.0 |  0.00
Modify  | 0.71814    | 0.71814    | 0.71814    |   0.0 |  0.39
Other   |            | 0.09707    |            |       |  0.05

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:       249008 ave      249008 max      249008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249008
Ave neighs/atom = 62.252
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.391156049669, Press = 0.503321626314475
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13897.996     -13897.996     -14031.73      -14031.73       258.71737      258.71737      47833.345      47833.345     -455.27608     -455.27608    
     33000  -13901.313     -13901.313     -14030.789     -14030.789      250.47853      250.47853      47817.099      47817.099      104.42801      104.42801    
Loop time of 206.457 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.349 hours/ns, 4.844 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.35     | 205.35     | 205.35     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16355    | 0.16355    | 0.16355    |   0.0 |  0.08
Output  | 0.00019786 | 0.00019786 | 0.00019786 |   0.0 |  0.00
Modify  | 0.83576    | 0.83576    | 0.83576    |   0.0 |  0.40
Other   |            | 0.1051     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248322 ave      248322 max      248322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248322
Ave neighs/atom = 62.0805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.36028115221, Press = 1.22582597654089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13901.313     -13901.313     -14030.789     -14030.789      250.47853      250.47853      47817.099      47817.099      104.42801      104.42801    
     34000  -13896.19      -13896.19      -14028.042     -14028.042      255.07556      255.07556      47802.734      47802.734      823.59452      823.59452    
Loop time of 207.119 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.533 hours/ns, 4.828 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.02     | 206.02     | 206.02     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16388    | 0.16388    | 0.16388    |   0.0 |  0.08
Output  | 0.00031665 | 0.00031665 | 0.00031665 |   0.0 |  0.00
Modify  | 0.83279    | 0.83279    | 0.83279    |   0.0 |  0.40
Other   |            | 0.1059     |            |       |  0.05

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:       248822 ave      248822 max      248822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248822
Ave neighs/atom = 62.2055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.349032814035, Press = 1.70587321240551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13896.19      -13896.19      -14028.042     -14028.042      255.07556      255.07556      47802.734      47802.734      823.59452      823.59452    
     35000  -13898.244     -13898.244     -14027.364     -14027.364      249.79162      249.79162      47747.566      47747.566      2404.1023      2404.1023    
Loop time of 190.185 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.454 ns/day, 52.829 hours/ns, 5.258 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 189.19     | 189.19     | 189.19     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15165    | 0.15165    | 0.15165    |   0.0 |  0.08
Output  | 0.00019335 | 0.00019335 | 0.00019335 |   0.0 |  0.00
Modify  | 0.74172    | 0.74172    | 0.74172    |   0.0 |  0.39
Other   |            | 0.09978    |            |       |  0.05

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:       249412 ave      249412 max      249412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249412
Ave neighs/atom = 62.353
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.373472286509, Press = 1.60656086777347
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13898.244     -13898.244     -14027.364     -14027.364      249.79162      249.79162      47747.566      47747.566      2404.1023      2404.1023    
     36000  -13894.933     -13894.933     -14027.668     -14027.668      256.7844       256.7844       47799.974      47799.974      1008.0477      1008.0477    
Loop time of 178.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.485 ns/day, 49.480 hours/ns, 5.614 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.21     | 177.21     | 177.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14689    | 0.14689    | 0.14689    |   0.0 |  0.08
Output  | 0.00018956 | 0.00018956 | 0.00018956 |   0.0 |  0.00
Modify  | 0.67433    | 0.67433    | 0.67433    |   0.0 |  0.38
Other   |            | 0.09402    |            |       |  0.05

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:       249830 ave      249830 max      249830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249830
Ave neighs/atom = 62.4575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.383836879419, Press = 0.376084331372004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13894.933     -13894.933     -14027.668     -14027.668      256.7844       256.7844       47799.974      47799.974      1008.0477      1008.0477    
     37000  -13899.239     -13899.239     -14028.224     -14028.224      249.52937      249.52937      47784.403      47784.403      1236.5297      1236.5297    
Loop time of 178.022 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.485 ns/day, 49.451 hours/ns, 5.617 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.11     | 177.11     | 177.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14322    | 0.14322    | 0.14322    |   0.0 |  0.08
Output  | 0.00023374 | 0.00023374 | 0.00023374 |   0.0 |  0.00
Modify  | 0.6749     | 0.6749     | 0.6749     |   0.0 |  0.38
Other   |            | 0.09353    |            |       |  0.05

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:       249102 ave      249102 max      249102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249102
Ave neighs/atom = 62.2755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.361526993566, Press = 0.181716500465411
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13899.239     -13899.239     -14028.224     -14028.224      249.52937      249.52937      47784.403      47784.403      1236.5297      1236.5297    
     38000  -13900.566     -13900.566     -14030.452     -14030.452      251.27257      251.27257      47787.114      47787.114      1014.6568      1014.6568    
Loop time of 199.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.396 hours/ns, 5.014 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.36     | 198.36     | 198.36     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16037    | 0.16037    | 0.16037    |   0.0 |  0.08
Output  | 0.00052947 | 0.00052947 | 0.00052947 |   0.0 |  0.00
Modify  | 0.80087    | 0.80087    | 0.80087    |   0.0 |  0.40
Other   |            | 0.1023     |            |       |  0.05

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:       249398 ave      249398 max      249398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249398
Ave neighs/atom = 62.3495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.342662732608, Press = 0.211635874686482
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13900.566     -13900.566     -14030.452     -14030.452      251.27257      251.27257      47787.114      47787.114      1014.6568      1014.6568    
     39000  -13897.715     -13897.715     -14029.802     -14029.802      255.53147      255.53147      47757.904      47757.904      1942.022       1942.022     
Loop time of 194.625 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.063 hours/ns, 5.138 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.59     | 193.59     | 193.59     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15622    | 0.15622    | 0.15622    |   0.0 |  0.08
Output  | 0.00019184 | 0.00019184 | 0.00019184 |   0.0 |  0.00
Modify  | 0.77339    | 0.77339    | 0.77339    |   0.0 |  0.40
Other   |            | 0.1021     |            |       |  0.05

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:       249084 ave      249084 max      249084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249084
Ave neighs/atom = 62.271
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.282060013887, Press = 0.513922202827183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13897.715     -13897.715     -14029.802     -14029.802      255.53147      255.53147      47757.904      47757.904      1942.022       1942.022     
     40000  -13900.231     -13900.231     -14028.61      -14028.61       248.35621      248.35621      47748.149      47748.149      2299.7478      2299.7478    
Loop time of 205.738 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.149 hours/ns, 4.861 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.64     | 204.64     | 204.64     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16326    | 0.16326    | 0.16326    |   0.0 |  0.08
Output  | 0.00024698 | 0.00024698 | 0.00024698 |   0.0 |  0.00
Modify  | 0.83034    | 0.83034    | 0.83034    |   0.0 |  0.40
Other   |            | 0.1048     |            |       |  0.05

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:       249338 ave      249338 max      249338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249338
Ave neighs/atom = 62.3345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.274826139986, Press = -0.465829999493225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13900.231     -13900.231     -14028.61      -14028.61       248.35621      248.35621      47748.149      47748.149      2299.7478      2299.7478    
     41000  -13896.84      -13896.84      -14029.124     -14029.124      255.91236      255.91236      47805.786      47805.786      636.85448      636.85448    
Loop time of 205.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.065 hours/ns, 4.868 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.33     | 204.33     | 204.33     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1647     | 0.1647     | 0.1647     |   0.0 |  0.08
Output  | 0.00019208 | 0.00019208 | 0.00019208 |   0.0 |  0.00
Modify  | 0.83174    | 0.83174    | 0.83174    |   0.0 |  0.40
Other   |            | 0.1058     |            |       |  0.05

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:       249668 ave      249668 max      249668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249668
Ave neighs/atom = 62.417
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.253990271191, Press = -0.293030529899379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13896.84      -13896.84      -14029.124     -14029.124      255.91236      255.91236      47805.786      47805.786      636.85448      636.85448    
     42000  -13901.627     -13901.627     -14029.805     -14029.805      247.96905      247.96905      47808.265      47808.265      334.42377      334.42377    
Loop time of 199.201 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.334 hours/ns, 5.020 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.13     | 198.13     | 198.13     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15985    | 0.15985    | 0.15985    |   0.0 |  0.08
Output  | 0.00019679 | 0.00019679 | 0.00019679 |   0.0 |  0.00
Modify  | 0.804      | 0.804      | 0.804      |   0.0 |  0.40
Other   |            | 0.1037     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248702 ave      248702 max      248702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248702
Ave neighs/atom = 62.1755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.218096476576, Press = -0.311867387722696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13901.627     -13901.627     -14029.805     -14029.805      247.96905      247.96905      47808.265      47808.265      334.42377      334.42377    
     43000  -13895.841     -13895.841     -14028.709     -14028.709      257.04072      257.04072      47825.837      47825.837      60.193632      60.193632    
Loop time of 198.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.113 hours/ns, 5.040 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.36     | 197.36     | 197.36     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15817    | 0.15817    | 0.15817    |   0.0 |  0.08
Output  | 0.00029954 | 0.00029954 | 0.00029954 |   0.0 |  0.00
Modify  | 0.78839    | 0.78839    | 0.78839    |   0.0 |  0.40
Other   |            | 0.1022     |            |       |  0.05

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:       249082 ave      249082 max      249082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 249082
Ave neighs/atom = 62.2705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.191002980715, Press = -0.25950082363658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13895.841     -13895.841     -14028.709     -14028.709      257.04072      257.04072      47825.837      47825.837      60.193632      60.193632    
     44000  -13899.554     -13899.554     -14031.188     -14031.188      254.65383      254.65383      47843.414      47843.414     -728.05141     -728.05141    
Loop time of 203.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.594 hours/ns, 4.908 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.65     | 202.65     | 202.65     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16285    | 0.16285    | 0.16285    |   0.0 |  0.08
Output  | 0.00026719 | 0.00026719 | 0.00026719 |   0.0 |  0.00
Modify  | 0.82085    | 0.82085    | 0.82085    |   0.0 |  0.40
Other   |            | 0.1044     |            |       |  0.05

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:       248902 ave      248902 max      248902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248902
Ave neighs/atom = 62.2255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.154055957784, Press = -1.49260621051702
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13899.554     -13899.554     -14031.188     -14031.188      254.65383      254.65383      47843.414      47843.414     -728.05141     -728.05141    
     45000  -13895.108     -13895.108     -14026.509     -14026.509      254.20387      254.20387      47898.193      47898.193     -1700.7869     -1700.7869    
Loop time of 198.04 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.011 hours/ns, 5.049 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.99     | 196.99     | 196.99     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15871    | 0.15871    | 0.15871    |   0.0 |  0.08
Output  | 0.00019368 | 0.00019368 | 0.00019368 |   0.0 |  0.00
Modify  | 0.78832    | 0.78832    | 0.78832    |   0.0 |  0.40
Other   |            | 0.1027     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       248280 ave      248280 max      248280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248280
Ave neighs/atom = 62.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.152113502562, Press = -1.53358503291889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13895.108     -13895.108     -14026.509     -14026.509      254.20387      254.20387      47898.193      47898.193     -1700.7869     -1700.7869    
     46000  -13899.362     -13899.362     -14030.421     -14030.421      253.54097      253.54097      47856.796      47856.796     -1015.5713     -1015.5713    
Loop time of 207.611 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.670 hours/ns, 4.817 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.5      | 206.5      | 206.5      |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16513    | 0.16513    | 0.16513    |   0.0 |  0.08
Output  | 0.00024497 | 0.00024497 | 0.00024497 |   0.0 |  0.00
Modify  | 0.84135    | 0.84135    | 0.84135    |   0.0 |  0.41
Other   |            | 0.1067     |            |       |  0.05

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:       248154 ave      248154 max      248154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248154
Ave neighs/atom = 62.0385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.169996834908, Press = -0.474806222269486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.7
  ghost atom cutoff = 5.7
  binsize = 2.85, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13899.362     -13899.362     -14030.421     -14030.421      253.54097      253.54097      47856.796      47856.796     -1015.5713     -1015.5713    
     47000  -13897.632     -13897.632     -14029.719     -14029.719      255.53116      255.53116      47860.767      47860.767     -1001.8706     -1001.8706    
Loop time of 206.649 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.402 hours/ns, 4.839 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.54     | 205.54     | 205.54     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16339    | 0.16339    | 0.16339    |   0.0 |  0.08
Output  | 0.00027025 | 0.00027025 | 0.00027025 |   0.0 |  0.00
Modify  | 0.83813    | 0.83813    | 0.83813    |   0.0 |  0.41
Other   |            | 0.1056     |            |       |  0.05

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:       248524 ave      248524 max      248524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 248524
Ave neighs/atom = 62.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
47826.4355907052

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0