# 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.613315634429455*${_u_distance}
variable latticeconst_converted equal 3.613315634429455*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331563442945
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.003 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_MirazDhariwalMeng_2020_CuNTi__MO_122936827583_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.6291336593    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6291336593/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6291336593/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6291336593/(1*1*${_u_distance})
variable      V0_metal equal 47175.6291336593/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47175.6291336593*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6291336593 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_122936827583_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 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.7681      2962.7681    
      1000  -13886.725     -13886.725     -14020.785     -14020.785      259.34741      259.34741      47843.18       47843.18      -1221.6303     -1221.6303    
Loop time of 482.568 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 481.62     | 481.62     | 481.62     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14998    | 0.14998    | 0.14998    |   0.0 |  0.03
Output  | 0.00025158 | 0.00025158 | 0.00025158 |   0.0 |  0.00
Modify  | 0.70053    | 0.70053    | 0.70053    |   0.0 |  0.15
Other   |            | 0.09875    |            |       |  0.02

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

Total # of neighbors = 536000
Ave neighs/atom = 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 = 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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13886.725     -13886.725     -14020.785     -14020.785      259.34741      259.34741      47843.18       47843.18      -1221.6303     -1221.6303    
      2000  -13897.661     -13897.661     -14029.472     -14029.472      254.99624      254.99624      47748.102      47748.102      319.83169      319.83169    
Loop time of 512.332 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.315 hours/ns, 1.952 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    | 511.35     | 511.35     | 511.35     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15434    | 0.15434    | 0.15434    |   0.0 |  0.03
Output  | 0.00032232 | 0.00032232 | 0.00032232 |   0.0 |  0.00
Modify  | 0.73095    | 0.73095    | 0.73095    |   0.0 |  0.14
Other   |            | 0.1016     |            |       |  0.02

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

Total # of neighbors = 532604
Ave neighs/atom = 133.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 = 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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13897.661     -13897.661     -14029.472     -14029.472      254.99624      254.99624      47748.102      47748.102      319.83169      319.83169    
      3000  -13894.228     -13894.228     -14024.796     -14024.796      252.59421      252.59421      47765.49       47765.49       302.37333      302.37333    
Loop time of 508.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.218 hours/ns, 1.967 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    | 507.4      | 507.4      | 507.4      |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15247    | 0.15247    | 0.15247    |   0.0 |  0.03
Output  | 0.00022984 | 0.00022984 | 0.00022984 |   0.0 |  0.00
Modify  | 0.72805    | 0.72805    | 0.72805    |   0.0 |  0.14
Other   |            | 0.1012     |            |       |  0.02

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

Total # of neighbors = 533570
Ave neighs/atom = 133.3925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13894.228     -13894.228     -14024.796     -14024.796      252.59421      252.59421      47765.49       47765.49       302.37333      302.37333    
      4000  -13896.619     -13896.619     -14024.158     -14024.158      246.73357      246.73357      47785.92       47785.92      -275.71262     -275.71262    
Loop time of 516.097 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.167 ns/day, 143.360 hours/ns, 1.938 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    | 515.1      | 515.1      | 515.1      |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15396    | 0.15396    | 0.15396    |   0.0 |  0.03
Output  | 0.00027351 | 0.00027351 | 0.00027351 |   0.0 |  0.00
Modify  | 0.73806    | 0.73806    | 0.73806    |   0.0 |  0.14
Other   |            | 0.1022     |            |       |  0.02

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

Total # of neighbors = 533110
Ave neighs/atom = 133.2775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13896.619     -13896.619     -14024.158     -14024.158      246.73357      246.73357      47785.92       47785.92      -275.71262     -275.71262    
      5000  -13896.611     -13896.611     -14024.725     -14024.725      247.84641      247.84641      47735.929      47735.929      971.62854      971.62854    
Loop time of 508.945 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.374 hours/ns, 1.965 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    | 507.97     | 507.97     | 507.97     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15208    | 0.15208    | 0.15208    |   0.0 |  0.03
Output  | 0.00023269 | 0.00023269 | 0.00023269 |   0.0 |  0.00
Modify  | 0.72537    | 0.72537    | 0.72537    |   0.0 |  0.14
Other   |            | 0.09983    |            |       |  0.02

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

Total # of neighbors = 532908
Ave neighs/atom = 133.227
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.182288116067, Press = -262.957282141985
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13896.611     -13896.611     -14024.725     -14024.725      247.84641      247.84641      47735.929      47735.929      971.62854      971.62854    
      6000  -13894.062     -13894.062     -14023.807     -14023.807      251.00066      251.00066      47819.181      47819.181     -1064.3062     -1064.3062    
Loop time of 514.695 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 142.971 hours/ns, 1.943 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    | 513.67     | 513.67     | 513.67     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15538    | 0.15538    | 0.15538    |   0.0 |  0.03
Output  | 0.00018987 | 0.00018987 | 0.00018987 |   0.0 |  0.00
Modify  | 0.77074    | 0.77074    | 0.77074    |   0.0 |  0.15
Other   |            | 0.1017     |            |       |  0.02

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

Total # of neighbors = 532998
Ave neighs/atom = 133.2495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.487794098004, Press = -14.919636317557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13894.062     -13894.062     -14023.807     -14023.807      251.00066      251.00066      47819.181      47819.181     -1064.3062     -1064.3062    
      7000  -13896.702     -13896.702     -14026.849     -14026.849      251.77848      251.77848      47686.353      47686.353      2116.2189      2116.2189    
Loop time of 511.585 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.107 hours/ns, 1.955 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    | 510.58     | 510.58     | 510.58     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15185    | 0.15185    | 0.15185    |   0.0 |  0.03
Output  | 0.00023775 | 0.00023775 | 0.00023775 |   0.0 |  0.00
Modify  | 0.75249    | 0.75249    | 0.75249    |   0.0 |  0.15
Other   |            | 0.1011     |            |       |  0.02

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

Total # of neighbors = 532620
Ave neighs/atom = 133.155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.050363388373, Press = 8.05955704895235
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13896.702     -13896.702     -14026.849     -14026.849      251.77848      251.77848      47686.353      47686.353      2116.2189      2116.2189    
      8000  -13896.407     -13896.407     -14025.898     -14025.898      250.5098       250.5098       47811.185      47811.185     -1032.4634     -1032.4634    
Loop time of 512.186 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.274 hours/ns, 1.952 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    | 511.17     | 511.17     | 511.17     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15476    | 0.15476    | 0.15476    |   0.0 |  0.03
Output  | 0.00024377 | 0.00024377 | 0.00024377 |   0.0 |  0.00
Modify  | 0.75873    | 0.75873    | 0.75873    |   0.0 |  0.15
Other   |            | 0.1012     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533578 ave      533578 max      533578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533578
Ave neighs/atom = 133.3945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.797658156124, Press = -17.811658910566
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13896.407     -13896.407     -14025.898     -14025.898      250.5098       250.5098       47811.185      47811.185     -1032.4634     -1032.4634    
      9000  -13893.894     -13893.894     -14025.058     -14025.058      253.74553      253.74553      47766.095      47766.095      249.07756      249.07756    
Loop time of 502.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.172 ns/day, 139.655 hours/ns, 1.989 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    | 501.77     | 501.77     | 501.77     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15094    | 0.15094    | 0.15094    |   0.0 |  0.03
Output  | 0.00028952 | 0.00028952 | 0.00028952 |   0.0 |  0.00
Modify  | 0.73873    | 0.73873    | 0.73873    |   0.0 |  0.15
Other   |            | 0.1        |            |       |  0.02

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

Total # of neighbors = 532866
Ave neighs/atom = 133.2165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.081506492396, Press = 3.05127090850473
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13893.894     -13893.894     -14025.058     -14025.058      253.74553      253.74553      47766.095      47766.095      249.07756      249.07756    
     10000  -13893.443     -13893.443     -14027.148     -14027.148      258.6613       258.6613       47770.931      47770.931      19.322149      19.322149    
Loop time of 510.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 141.931 hours/ns, 1.957 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    | 509.95     | 509.95     | 509.95     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15412    | 0.15412    | 0.15412    |   0.0 |  0.03
Output  | 0.00019408 | 0.00019408 | 0.00019408 |   0.0 |  0.00
Modify  | 0.75026    | 0.75026    | 0.75026    |   0.0 |  0.15
Other   |            | 0.1009     |            |       |  0.02

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

Total # of neighbors = 533002
Ave neighs/atom = 133.2505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.193742673291, Press = -6.04329154729299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13893.443     -13893.443     -14027.148     -14027.148      258.6613       258.6613       47770.931      47770.931      19.322149      19.322149    
     11000  -13893.966     -13893.966     -14026.474     -14026.474      256.34559      256.34559      47813.485      47813.485     -1096.8242     -1096.8242    
Loop time of 509.37 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.492 hours/ns, 1.963 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    | 508.36     | 508.36     | 508.36     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15314    | 0.15314    | 0.15314    |   0.0 |  0.03
Output  | 0.00019135 | 0.00019135 | 0.00019135 |   0.0 |  0.00
Modify  | 0.75184    | 0.75184    | 0.75184    |   0.0 |  0.15
Other   |            | 0.1001     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5849 ave        5849 max        5849 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533072 ave      533072 max      533072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533072
Ave neighs/atom = 133.268
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.479025716422, Press = -0.434435929301669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13893.966     -13893.966     -14026.474     -14026.474      256.34559      256.34559      47813.485      47813.485     -1096.8242     -1096.8242    
     12000  -13896.74      -13896.74      -14026.214     -14026.214      250.47538      250.47538      47687.722      47687.722      2073.9016      2073.9016    
Loop time of 505.13 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.314 hours/ns, 1.980 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    | 504.13     | 504.13     | 504.13     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15333    | 0.15333    | 0.15333    |   0.0 |  0.03
Output  | 0.00019193 | 0.00019193 | 0.00019193 |   0.0 |  0.00
Modify  | 0.74599    | 0.74599    | 0.74599    |   0.0 |  0.15
Other   |            | 0.09961    |            |       |  0.02

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

Total # of neighbors = 532834
Ave neighs/atom = 133.2085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.491281242666, Press = 0.364388464475389
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13896.74      -13896.74      -14026.214     -14026.214      250.47538      250.47538      47687.722      47687.722      2073.9016      2073.9016    
     13000  -13898.52      -13898.52      -14027.926     -14027.926      250.34434      250.34434      47828.096      47828.096     -1655.1569     -1655.1569    
Loop time of 512.087 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.246 hours/ns, 1.953 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    | 511.08     | 511.08     | 511.08     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15381    | 0.15381    | 0.15381    |   0.0 |  0.03
Output  | 0.00019257 | 0.00019257 | 0.00019257 |   0.0 |  0.00
Modify  | 0.75613    | 0.75613    | 0.75613    |   0.0 |  0.15
Other   |            | 0.1012     |            |       |  0.02

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

Total # of neighbors = 533272
Ave neighs/atom = 133.318
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.400177610805, Press = -7.51478537515371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13898.52      -13898.52      -14027.926     -14027.926      250.34434      250.34434      47828.096      47828.096     -1655.1569     -1655.1569    
     14000  -13896.483     -13896.483     -14027.658     -14027.658      253.76576      253.76576      47755.228      47755.228      280.42051      280.42051    
Loop time of 515.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.167 ns/day, 143.331 hours/ns, 1.938 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    | 514.97     | 514.97     | 514.97     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15456    | 0.15456    | 0.15456    |   0.0 |  0.03
Output  | 0.00049665 | 0.00049665 | 0.00049665 |   0.0 |  0.00
Modify  | 0.76567    | 0.76567    | 0.76567    |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

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

Total # of neighbors = 532984
Ave neighs/atom = 133.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.353411070844, Press = 1.98041226104858
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13896.483     -13896.483     -14027.658     -14027.658      253.76576      253.76576      47755.228      47755.228      280.42051      280.42051    
     15000  -13896.52      -13896.52      -14026.233     -14026.233      250.93985      250.93985      47764.978      47764.978      137.79895      137.79895    
Loop time of 511.151 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 141.986 hours/ns, 1.956 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    | 510.13     | 510.13     | 510.13     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15492    | 0.15492    | 0.15492    |   0.0 |  0.03
Output  | 0.00019098 | 0.00019098 | 0.00019098 |   0.0 |  0.00
Modify  | 0.76474    | 0.76474    | 0.76474    |   0.0 |  0.15
Other   |            | 0.1018     |            |       |  0.02

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

Total # of neighbors = 533274
Ave neighs/atom = 133.3185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.206234203698, Press = -2.3821699187512
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13896.52      -13896.52      -14026.233     -14026.233      250.93985      250.93985      47764.978      47764.978      137.79895      137.79895    
     16000  -13896.541     -13896.541     -14026.293     -14026.293      251.01453      251.01453      47774.689      47774.689     -134.7361      -134.7361     
Loop time of 512.372 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.326 hours/ns, 1.952 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    | 511.36     | 511.36     | 511.36     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15524    | 0.15524    | 0.15524    |   0.0 |  0.03
Output  | 0.00019179 | 0.00019179 | 0.00019179 |   0.0 |  0.00
Modify  | 0.75952    | 0.75952    | 0.75952    |   0.0 |  0.15
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5844 ave        5844 max        5844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533070 ave      533070 max      533070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533070
Ave neighs/atom = 133.2675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.225034516655, Press = -0.487794385277702
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13896.541     -13896.541     -14026.293     -14026.293      251.01453      251.01453      47774.689      47774.689     -134.7361      -134.7361     
     17000  -13896.197     -13896.197     -14026.291     -14026.291      251.67568      251.67568      47739.226      47739.226      780.34773      780.34773    
Loop time of 515.542 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 143.206 hours/ns, 1.940 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    | 514.52     | 514.52     | 514.52     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15488    | 0.15488    | 0.15488    |   0.0 |  0.03
Output  | 0.00018905 | 0.00018905 | 0.00018905 |   0.0 |  0.00
Modify  | 0.76917    | 0.76917    | 0.76917    |   0.0 |  0.15
Other   |            | 0.1026     |            |       |  0.02

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

Total # of neighbors = 532950
Ave neighs/atom = 133.2375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.160948661076, Press = -0.860032365045103
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13896.197     -13896.197     -14026.291     -14026.291      251.67568      251.67568      47739.226      47739.226      780.34773      780.34773    
     18000  -13895.224     -13895.224     -14024.253     -14024.253      249.61493      249.61493      47820.068      47820.068     -1149.7307     -1149.7307    
Loop time of 515.107 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 143.085 hours/ns, 1.941 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    | 514.07     | 514.07     | 514.07     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15575    | 0.15575    | 0.15575    |   0.0 |  0.03
Output  | 0.00023115 | 0.00023115 | 0.00023115 |   0.0 |  0.00
Modify  | 0.77421    | 0.77421    | 0.77421    |   0.0 |  0.15
Other   |            | 0.1024     |            |       |  0.02

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

Total # of neighbors = 533264
Ave neighs/atom = 133.316
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.135105085053, Press = -2.59831059416972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13895.224     -13895.224     -14024.253     -14024.253      249.61493      249.61493      47820.068      47820.068     -1149.7307     -1149.7307    
     19000  -13895.061     -13895.061     -14028.492     -14028.492      258.13044      258.13044      47751.74       47751.74       322.96831      322.96831    
Loop time of 508.716 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.310 hours/ns, 1.966 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    | 507.71     | 507.71     | 507.71     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15263    | 0.15263    | 0.15263    |   0.0 |  0.03
Output  | 0.00019197 | 0.00019197 | 0.00019197 |   0.0 |  0.00
Modify  | 0.75343    | 0.75343    | 0.75343    |   0.0 |  0.15
Other   |            | 0.1014     |            |       |  0.02

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

Total # of neighbors = 532712
Ave neighs/atom = 133.178
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.085597707875, Press = 0.983706800921063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13895.061     -13895.061     -14028.492     -14028.492      258.13044      258.13044      47751.74       47751.74       322.96831      322.96831    
     20000  -13894.201     -13894.201     -14025.635     -14025.635      254.26749      254.26749      47779.132      47779.132     -212.79617     -212.79617    
Loop time of 510.226 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 141.729 hours/ns, 1.960 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    | 509.22     | 509.22     | 509.22     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15397    | 0.15397    | 0.15397    |   0.0 |  0.03
Output  | 0.00018964 | 0.00018964 | 0.00018964 |   0.0 |  0.00
Modify  | 0.75016    | 0.75016    | 0.75016    |   0.0 |  0.15
Other   |            | 0.1003     |            |       |  0.02

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

Total # of neighbors = 533098
Ave neighs/atom = 133.2745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.233966184142, Press = -3.67346967466529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13894.201     -13894.201     -14025.635     -14025.635      254.26749      254.26749      47779.132      47779.132     -212.79617     -212.79617    
     21000  -13896.627     -13896.627     -14027.289     -14027.289      252.77527      252.77527      47771.722      47771.722     -160.43551     -160.43551    
Loop time of 513.153 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 142.542 hours/ns, 1.949 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    | 512.14     | 512.14     | 512.14     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1536     | 0.1536     | 0.1536     |   0.0 |  0.03
Output  | 0.00018866 | 0.00018866 | 0.00018866 |   0.0 |  0.00
Modify  | 0.76232    | 0.76232    | 0.76232    |   0.0 |  0.15
Other   |            | 0.1014     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       532832 ave      532832 max      532832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532832
Ave neighs/atom = 133.208
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.269826125229, Press = 2.16471571515974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13896.627     -13896.627     -14027.289     -14027.289      252.77527      252.77527      47771.722      47771.722     -160.43551     -160.43551    
     22000  -13896.372     -13896.372     -14024.84      -14024.84       248.53023      248.53023      47717.124      47717.124      1442.3286      1442.3286    
Loop time of 507.299 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 140.916 hours/ns, 1.971 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    | 506.29     | 506.29     | 506.29     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15282    | 0.15282    | 0.15282    |   0.0 |  0.03
Output  | 0.00019076 | 0.00019076 | 0.00019076 |   0.0 |  0.00
Modify  | 0.75273    | 0.75273    | 0.75273    |   0.0 |  0.15
Other   |            | 0.1013     |            |       |  0.02

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

Total # of neighbors = 532888
Ave neighs/atom = 133.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.328099924979, Press = -4.23531391790825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13896.372     -13896.372     -14024.84      -14024.84       248.53023      248.53023      47717.124      47717.124      1442.3286      1442.3286    
     23000  -13892.351     -13892.351     -14024.937     -14024.937      256.49656      256.49656      47831.365      47831.365     -1413.831      -1413.831     
Loop time of 509.222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.450 hours/ns, 1.964 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    | 508.21     | 508.21     | 508.21     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15393    | 0.15393    | 0.15393    |   0.0 |  0.03
Output  | 0.00019184 | 0.00019184 | 0.00019184 |   0.0 |  0.00
Modify  | 0.75318    | 0.75318    | 0.75318    |   0.0 |  0.15
Other   |            | 0.1005     |            |       |  0.02

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

Total # of neighbors = 533042
Ave neighs/atom = 133.2605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.327466473142, Press = 0.898076084181393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13892.351     -13892.351     -14024.937     -14024.937      256.49656      256.49656      47831.365      47831.365     -1413.831      -1413.831     
     24000  -13895.304     -13895.304     -14026.831     -14026.831      254.44633      254.44633      47756.398      47756.398      318.29356      318.29356    
Loop time of 510.498 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 141.805 hours/ns, 1.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    | 509.48     | 509.48     | 509.48     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15351    | 0.15351    | 0.15351    |   0.0 |  0.03
Output  | 0.00019247 | 0.00019247 | 0.00019247 |   0.0 |  0.00
Modify  | 0.75946    | 0.75946    | 0.75946    |   0.0 |  0.15
Other   |            | 0.1018     |            |       |  0.02

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

Total # of neighbors = 532574
Ave neighs/atom = 133.1435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.426778640274, Press = -0.700350956002022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13895.304     -13895.304     -14026.831     -14026.831      254.44633      254.44633      47756.398      47756.398      318.29356      318.29356    
     25000  -13893.149     -13893.149     -14024.869     -14024.869      254.81947      254.81947      47781.437      47781.437     -141.16327     -141.16327    
Loop time of 512.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.224 hours/ns, 1.953 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    | 510.99     | 510.99     | 510.99     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15431    | 0.15431    | 0.15431    |   0.0 |  0.03
Output  | 0.00028511 | 0.00028511 | 0.00028511 |   0.0 |  0.00
Modify  | 0.75802    | 0.75802    | 0.75802    |   0.0 |  0.15
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533144 ave      533144 max      533144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533144
Ave neighs/atom = 133.286
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.448525647734, Press = -0.669022560686089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13893.149     -13893.149     -14024.869     -14024.869      254.81947      254.81947      47781.437      47781.437     -141.16327     -141.16327    
     26000  -13896.261     -13896.261     -14027.911     -14027.911      254.68549      254.68549      47757.38       47757.38       195.40044      195.40044    
Loop time of 505.456 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.404 hours/ns, 1.978 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    | 504.46     | 504.46     | 504.46     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15183    | 0.15183    | 0.15183    |   0.0 |  0.03
Output  | 0.0002621  | 0.0002621  | 0.0002621  |   0.0 |  0.00
Modify  | 0.74581    | 0.74581    | 0.74581    |   0.0 |  0.15
Other   |            | 0.1004     |            |       |  0.02

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

Total # of neighbors = 532922
Ave neighs/atom = 133.2305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456741885692, Press = -0.923033550732639
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13896.261     -13896.261     -14027.911     -14027.911      254.68549      254.68549      47757.38       47757.38       195.40044      195.40044    
     27000  -13895.803     -13895.803     -14027.73      -14027.73       255.22254      255.22254      47790.326      47790.326     -638.91743     -638.91743    
Loop time of 514.48 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 142.911 hours/ns, 1.944 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    | 513.46     | 513.46     | 513.46     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15347    | 0.15347    | 0.15347    |   0.0 |  0.03
Output  | 0.00019141 | 0.00019141 | 0.00019141 |   0.0 |  0.00
Modify  | 0.76432    | 0.76432    | 0.76432    |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533206 ave      533206 max      533206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533206
Ave neighs/atom = 133.3015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.428513187426, Press = -1.231762195937
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13895.803     -13895.803     -14027.73      -14027.73       255.22254      255.22254      47790.326      47790.326     -638.91743     -638.91743    
     28000  -13898.412     -13898.412     -14027.645     -14027.645      250.01011      250.01011      47761.2        47761.2        100.66171      100.66171    
Loop time of 515.492 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 143.192 hours/ns, 1.940 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    | 514.48     | 514.48     | 514.48     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15378    | 0.15378    | 0.15378    |   0.0 |  0.03
Output  | 0.0001895  | 0.0001895  | 0.0001895  |   0.0 |  0.00
Modify  | 0.76019    | 0.76019    | 0.76019    |   0.0 |  0.15
Other   |            | 0.1011     |            |       |  0.02

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

Total # of neighbors = 533022
Ave neighs/atom = 133.2555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.365487671752, Press = 1.33218865564865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13898.412     -13898.412     -14027.645     -14027.645      250.01011      250.01011      47761.2        47761.2        100.66171      100.66171    
     29000  -13893.532     -13893.532     -14026.553     -14026.553      257.33855      257.33855      47744.193      47744.193      668.96661      668.96661    
Loop time of 515.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 143.106 hours/ns, 1.941 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    | 514.16     | 514.16     | 514.16     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15475    | 0.15475    | 0.15475    |   0.0 |  0.03
Output  | 0.00023438 | 0.00023438 | 0.00023438 |   0.0 |  0.00
Modify  | 0.7688     | 0.7688     | 0.7688     |   0.0 |  0.15
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       532994 ave      532994 max      532994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532994
Ave neighs/atom = 133.2485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.406570656521, Press = -2.52489174313806
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13893.532     -13893.532     -14026.553     -14026.553      257.33855      257.33855      47744.193      47744.193      668.96661      668.96661    
     30000  -13897.007     -13897.007     -14029.652     -14029.652      256.61158      256.61158      47818.501      47818.501     -1536.8224     -1536.8224    
Loop time of 511.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.057 hours/ns, 1.955 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    | 510.39     | 510.39     | 510.39     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15392    | 0.15392    | 0.15392    |   0.0 |  0.03
Output  | 0.00023491 | 0.00023491 | 0.00023491 |   0.0 |  0.00
Modify  | 0.75876    | 0.75876    | 0.75876    |   0.0 |  0.15
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533074 ave      533074 max      533074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533074
Ave neighs/atom = 133.2685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.436070703051, Press = 0.426675908493338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13897.007     -13897.007     -14029.652     -14029.652      256.61158      256.61158      47818.501      47818.501     -1536.8224     -1536.8224    
     31000  -13892.862     -13892.862     -14025.247     -14025.247      256.10784      256.10784      47739.773      47739.773      898.77882      898.77882    
Loop time of 512.842 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 142.456 hours/ns, 1.950 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    | 511.83     | 511.83     | 511.83     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15443    | 0.15443    | 0.15443    |   0.0 |  0.03
Output  | 0.00019153 | 0.00019153 | 0.00019153 |   0.0 |  0.00
Modify  | 0.756      | 0.756      | 0.756      |   0.0 |  0.15
Other   |            | 0.1009     |            |       |  0.02

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

Total # of neighbors = 533078
Ave neighs/atom = 133.2695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.42299882787, Press = -0.743202701290912
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13892.862     -13892.862     -14025.247     -14025.247      256.10784      256.10784      47739.773      47739.773      898.77882      898.77882    
     32000  -13897.277     -13897.277     -14027.334     -14027.334      251.60306      251.60306      47810.872      47810.872     -1094.445      -1094.445     
Loop time of 513.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 142.748 hours/ns, 1.946 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    | 512.87     | 512.87     | 512.87     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15508    | 0.15508    | 0.15508    |   0.0 |  0.03
Output  | 0.00019129 | 0.00019129 | 0.00019129 |   0.0 |  0.00
Modify  | 0.76889    | 0.76889    | 0.76889    |   0.0 |  0.15
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533040 ave      533040 max      533040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533040
Ave neighs/atom = 133.26
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.423928298741, Press = -1.17490174102743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13897.277     -13897.277     -14027.334     -14027.334      251.60306      251.60306      47810.872      47810.872     -1094.445      -1094.445     
     33000  -13895.46      -13895.46      -14026.782     -14026.782      254.05129      254.05129      47756.21       47756.21       352.23576      352.23576    
Loop time of 513.257 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 142.571 hours/ns, 1.948 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    | 512.24     | 512.24     | 512.24     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15455    | 0.15455    | 0.15455    |   0.0 |  0.03
Output  | 0.00024265 | 0.00024265 | 0.00024265 |   0.0 |  0.00
Modify  | 0.75715    | 0.75715    | 0.75715    |   0.0 |  0.15
Other   |            | 0.1015     |            |       |  0.02

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

Total # of neighbors = 533180
Ave neighs/atom = 133.295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.468857446939, Press = 0.60392524584211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13895.46      -13895.46      -14026.782     -14026.782      254.05129      254.05129      47756.21       47756.21       352.23576      352.23576    
     34000  -13893.675     -13893.675     -14024.53      -14024.53       253.14656      253.14656      47766.787      47766.787      289.90778      289.90778    
Loop time of 514.914 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 143.032 hours/ns, 1.942 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    | 513.9      | 513.9      | 513.9      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15433    | 0.15433    | 0.15433    |   0.0 |  0.03
Output  | 0.00019167 | 0.00019167 | 0.00019167 |   0.0 |  0.00
Modify  | 0.75534    | 0.75534    | 0.75534    |   0.0 |  0.15
Other   |            | 0.101      |            |       |  0.02

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

Total # of neighbors = 533212
Ave neighs/atom = 133.303
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.466193314718, Press = -1.35805043153929
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13893.675     -13893.675     -14024.53      -14024.53       253.14656      253.14656      47766.787      47766.787      289.90778      289.90778    
     35000  -13898.559     -13898.559     -14028.578     -14028.578      251.53123      251.53123      47822.364      47822.364     -1527.6275     -1527.6275    
Loop time of 514.922 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 143.034 hours/ns, 1.942 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    | 513.91     | 513.91     | 513.91     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15423    | 0.15423    | 0.15423    |   0.0 |  0.03
Output  | 0.00023263 | 0.00023263 | 0.00023263 |   0.0 |  0.00
Modify  | 0.76125    | 0.76125    | 0.76125    |   0.0 |  0.15
Other   |            | 0.1012     |            |       |  0.02

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

Total # of neighbors = 533176
Ave neighs/atom = 133.294
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.441571447617, Press = 0.426126284487844
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13898.559     -13898.559     -14028.578     -14028.578      251.53123      251.53123      47822.364      47822.364     -1527.6275     -1527.6275    
     36000  -13896.549     -13896.549     -14028.888     -14028.888      256.01861      256.01861      47654.088      47654.088      2823.7841      2823.7841    
Loop time of 520.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.166 ns/day, 144.533 hours/ns, 1.922 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    | 519.29     | 519.29     | 519.29     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15541    | 0.15541    | 0.15541    |   0.0 |  0.03
Output  | 0.00018982 | 0.00018982 | 0.00018982 |   0.0 |  0.00
Modify  | 0.77231    | 0.77231    | 0.77231    |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

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

Total # of neighbors = 532938
Ave neighs/atom = 133.2345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.410572413022, Press = -0.764987262325834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13896.549     -13896.549     -14028.888     -14028.888      256.01861      256.01861      47654.088      47654.088      2823.7841      2823.7841    
     37000  -13895.155     -13895.155     -14024.817     -14024.817      250.84011      250.84011      47830.057      47830.057     -1384.6493     -1384.6493    
Loop time of 516.836 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.167 ns/day, 143.566 hours/ns, 1.935 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    | 515.81     | 515.81     | 515.81     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15421    | 0.15421    | 0.15421    |   0.0 |  0.03
Output  | 0.00023914 | 0.00023914 | 0.00023914 |   0.0 |  0.00
Modify  | 0.76489    | 0.76489    | 0.76489    |   0.0 |  0.15
Other   |            | 0.1019     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533738 ave      533738 max      533738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533738
Ave neighs/atom = 133.4345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.38352363521, Press = -0.643058338834954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13895.155     -13895.155     -14024.817     -14024.817      250.84011      250.84011      47830.057      47830.057     -1384.6493     -1384.6493    
     38000  -13893.644     -13893.644     -14024.858     -14024.858      253.84188      253.84188      47744.984      47744.984      791.63723      791.63723    
Loop time of 512.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.379 hours/ns, 1.951 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    | 511.55     | 511.55     | 511.55     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15368    | 0.15368    | 0.15368    |   0.0 |  0.03
Output  | 0.00019101 | 0.00019101 | 0.00019101 |   0.0 |  0.00
Modify  | 0.7579     | 0.7579     | 0.7579     |   0.0 |  0.15
Other   |            | 0.1007     |            |       |  0.02

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

Total # of neighbors = 532796
Ave neighs/atom = 133.199
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.433239518718, Press = 0.33124863225396
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13893.644     -13893.644     -14024.858     -14024.858      253.84188      253.84188      47744.984      47744.984      791.63723      791.63723    
     39000  -13896.364     -13896.364     -14027.024     -14027.024      252.7711       252.7711       47779.194      47779.194     -292.04195     -292.04195    
Loop time of 513.584 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 142.662 hours/ns, 1.947 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    | 512.56     | 512.56     | 512.56     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15445    | 0.15445    | 0.15445    |   0.0 |  0.03
Output  | 0.00019519 | 0.00019519 | 0.00019519 |   0.0 |  0.00
Modify  | 0.76348    | 0.76348    | 0.76348    |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533058 ave      533058 max      533058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533058
Ave neighs/atom = 133.2645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.443728666551, Press = -1.09569333867573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13896.364     -13896.364     -14027.024     -14027.024      252.7711       252.7711       47779.194      47779.194     -292.04195     -292.04195    
     40000  -13893.779     -13893.779     -14025.002     -14025.002      253.86102      253.86102      47783.594      47783.594     -214.58668     -214.58668    
Loop time of 513.943 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 142.762 hours/ns, 1.946 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    | 512.93     | 512.93     | 512.93     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15299    | 0.15299    | 0.15299    |   0.0 |  0.03
Output  | 0.00019286 | 0.00019286 | 0.00019286 |   0.0 |  0.00
Modify  | 0.76107    | 0.76107    | 0.76107    |   0.0 |  0.15
Other   |            | 0.1012     |            |       |  0.02

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

Total # of neighbors = 533076
Ave neighs/atom = 133.269
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.45880315, Press = 0.642195549350648
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13893.779     -13893.779     -14025.002     -14025.002      253.86102      253.86102      47783.594      47783.594     -214.58668     -214.58668    
     41000  -13896.439     -13896.439     -14025.772     -14025.772      250.20194      250.20194      47752.975      47752.975      481.72945      481.72945    
Loop time of 517.979 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.167 ns/day, 143.883 hours/ns, 1.931 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    | 516.95     | 516.95     | 516.95     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15532    | 0.15532    | 0.15532    |   0.0 |  0.03
Output  | 0.00024473 | 0.00024473 | 0.00024473 |   0.0 |  0.00
Modify  | 0.77334    | 0.77334    | 0.77334    |   0.0 |  0.15
Other   |            | 0.1027     |            |       |  0.02

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

Total # of neighbors = 532814
Ave neighs/atom = 133.2035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.448431133451, Press = -1.17383720259074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13896.439     -13896.439     -14025.772     -14025.772      250.20194      250.20194      47752.975      47752.975      481.72945      481.72945    
     42000  -13897.544     -13897.544     -14028.813     -14028.813      253.94981      253.94981      47800.368      47800.368     -970.54481     -970.54481    
Loop time of 517.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.167 ns/day, 143.792 hours/ns, 1.932 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    | 516.62     | 516.62     | 516.62     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15527    | 0.15527    | 0.15527    |   0.0 |  0.03
Output  | 0.00018899 | 0.00018899 | 0.00018899 |   0.0 |  0.00
Modify  | 0.77096    | 0.77096    | 0.77096    |   0.0 |  0.15
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533236 ave      533236 max      533236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533236
Ave neighs/atom = 133.309
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.459094481052, Press = 0.30515890087873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13897.544     -13897.544     -14028.813     -14028.813      253.94981      253.94981      47800.368      47800.368     -970.54481     -970.54481    
     43000  -13895.378     -13895.378     -14025.826     -14025.826      252.36001      252.36001      47749.218      47749.218      591.25752      591.25752    
Loop time of 515.427 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.168 ns/day, 143.174 hours/ns, 1.940 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    | 514.4      | 514.4      | 514.4      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1549     | 0.1549     | 0.1549     |   0.0 |  0.03
Output  | 0.0001897  | 0.0001897  | 0.0001897  |   0.0 |  0.00
Modify  | 0.7723     | 0.7723     | 0.7723     |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

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

Total # of neighbors = 533044
Ave neighs/atom = 133.261
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.491426937016, Press = -0.0394552491947842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13895.378     -13895.378     -14025.826     -14025.826      252.36001      252.36001      47749.218      47749.218      591.25752      591.25752    
     44000  -13900.229     -13900.229     -14028.187     -14028.187      247.54272      247.54272      47773.942      47773.942     -311.55145     -311.55145    
Loop time of 511.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.152 hours/ns, 1.954 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    | 510.74     | 510.74     | 510.74     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15186    | 0.15186    | 0.15186    |   0.0 |  0.03
Output  | 0.00018968 | 0.00018968 | 0.00018968 |   0.0 |  0.00
Modify  | 0.75476    | 0.75476    | 0.75476    |   0.0 |  0.15
Other   |            | 0.1014     |            |       |  0.02

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

Total # of neighbors = 533036
Ave neighs/atom = 133.259
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.475073014069, Press = -0.65164255933106
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13900.229     -13900.229     -14028.187     -14028.187      247.54272      247.54272      47773.942      47773.942     -311.55145     -311.55145    
     45000  -13894.105     -13894.105     -14025.395     -14025.395      253.98961      253.98961      47744.357      47744.357      763.3749       763.3749     
Loop time of 512.757 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.432 hours/ns, 1.950 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    | 511.74     | 511.74     | 511.74     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15426    | 0.15426    | 0.15426    |   0.0 |  0.03
Output  | 0.00019118 | 0.00019118 | 0.00019118 |   0.0 |  0.00
Modify  | 0.7598     | 0.7598     | 0.7598     |   0.0 |  0.15
Other   |            | 0.1011     |            |       |  0.02

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

Total # of neighbors = 533084
Ave neighs/atom = 133.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.445041562651, Press = 0.410027128802299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13894.105     -13894.105     -14025.395     -14025.395      253.98961      253.98961      47744.357      47744.357      763.3749       763.3749     
     46000  -13899.937     -13899.937     -14026.368     -14026.368      244.58952      244.58952      47742.856      47742.856      578.62566      578.62566    
Loop time of 512.083 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.245 hours/ns, 1.953 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    | 511.07     | 511.07     | 511.07     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15375    | 0.15375    | 0.15375    |   0.0 |  0.03
Output  | 0.00024155 | 0.00024155 | 0.00024155 |   0.0 |  0.00
Modify  | 0.76034    | 0.76034    | 0.76034    |   0.0 |  0.15
Other   |            | 0.1015     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533114 ave      533114 max      533114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533114
Ave neighs/atom = 133.2785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40418207553, Press = -1.07758092478393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13899.937     -13899.937     -14026.368     -14026.368      244.58952      244.58952      47742.856      47742.856      578.62566      578.62566    
     47000  -13895.802     -13895.802     -14027.969     -14027.969      255.68557      255.68557      47788.249      47788.249     -570.04112     -570.04112    
Loop time of 511.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.119 hours/ns, 1.955 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    | 510.62     | 510.62     | 510.62     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15301    | 0.15301    | 0.15301    |   0.0 |  0.03
Output  | 0.00023282 | 0.00023282 | 0.00023282 |   0.0 |  0.00
Modify  | 0.75489    | 0.75489    | 0.75489    |   0.0 |  0.15
Other   |            | 0.1004     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533032 ave      533032 max      533032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533032
Ave neighs/atom = 133.258
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.407768267932, Press = 0.361099873457034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13895.802     -13895.802     -14027.969     -14027.969      255.68557      255.68557      47788.249      47788.249     -570.04112     -570.04112    
     48000  -13897.162     -13897.162     -14028.339     -14028.339      253.77201      253.77201      47729.251      47729.251      888.66647      888.66647    
Loop time of 511.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 142.203 hours/ns, 1.953 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    | 510.91     | 510.91     | 510.91     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15484    | 0.15484    | 0.15484    |   0.0 |  0.03
Output  | 0.00022591 | 0.00022591 | 0.00022591 |   0.0 |  0.00
Modify  | 0.76371    | 0.76371    | 0.76371    |   0.0 |  0.15
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5846 ave        5846 max        5846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533240 ave      533240 max      533240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533240
Ave neighs/atom = 133.31
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.425464288968, Press = -0.686698458244995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13897.162     -13897.162     -14028.339     -14028.339      253.77201      253.77201      47729.251      47729.251      888.66647      888.66647    
     49000  -13892.852     -13892.852     -14023.799     -14023.799      253.32491      253.32491      47882.559      47882.559     -2617.2717     -2617.2717    
Loop time of 511.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 141.950 hours/ns, 1.957 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    | 510.01     | 510.01     | 510.01     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15262    | 0.15262    | 0.15262    |   0.0 |  0.03
Output  | 0.00029305 | 0.00029305 | 0.00029305 |   0.0 |  0.00
Modify  | 0.75503    | 0.75503    | 0.75503    |   0.0 |  0.15
Other   |            | 0.1014     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533238 ave      533238 max      533238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533238
Ave neighs/atom = 133.3095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.437747045124, Press = -0.596281790438713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13892.852     -13892.852     -14023.799     -14023.799      253.32491      253.32491      47882.559      47882.559     -2617.2717     -2617.2717    
     50000  -13894.454     -13894.454     -14026.967     -14026.967      256.35702      256.35702      47708.856      47708.856      1558.4299      1558.4299    
Loop time of 501.854 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.172 ns/day, 139.404 hours/ns, 1.993 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    | 500.86     | 500.86     | 500.86     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15137    | 0.15137    | 0.15137    |   0.0 |  0.03
Output  | 0.00019108 | 0.00019108 | 0.00019108 |   0.0 |  0.00
Modify  | 0.73786    | 0.73786    | 0.73786    |   0.0 |  0.15
Other   |            | 0.1001     |            |       |  0.02

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

Total # of neighbors = 532602
Ave neighs/atom = 133.1505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.440343626987, Press = 0.500393142744668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13894.454     -13894.454     -14026.967     -14026.967      256.35702      256.35702      47708.856      47708.856      1558.4299      1558.4299    
     51000  -13894.524     -13894.524     -14025.86      -14025.86       254.07786      254.07786      47794.531      47794.531     -561.42747     -561.42747    
Loop time of 502.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.172 ns/day, 139.620 hours/ns, 1.990 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    | 501.64     | 501.64     | 501.64     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15104    | 0.15104    | 0.15104    |   0.0 |  0.03
Output  | 0.00019492 | 0.00019492 | 0.00019492 |   0.0 |  0.00
Modify  | 0.73919    | 0.73919    | 0.73919    |   0.0 |  0.15
Other   |            | 0.0997     |            |       |  0.02

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

Total # of neighbors = 533330
Ave neighs/atom = 133.3325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.467265024212, Press = -0.614913569322617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13894.524     -13894.524     -14025.86      -14025.86       254.07786      254.07786      47794.531      47794.531     -561.42747     -561.42747    
     52000  -13895.609     -13895.609     -14025.418     -14025.418      251.12461      251.12461      47773.754      47773.754     -21.059014     -21.059014    
Loop time of 504.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.122 hours/ns, 1.982 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    | 503.45     | 503.45     | 503.45     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15079    | 0.15079    | 0.15079    |   0.0 |  0.03
Output  | 0.00055726 | 0.00055726 | 0.00055726 |   0.0 |  0.00
Modify  | 0.73742    | 0.73742    | 0.73742    |   0.0 |  0.15
Other   |            | 0.1        |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       532930 ave      532930 max      532930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532930
Ave neighs/atom = 133.2325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456233824986, Press = 0.570008187246467
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13895.609     -13895.609     -14025.418     -14025.418      251.12461      251.12461      47773.754      47773.754     -21.059014     -21.059014    
     53000  -13895.597     -13895.597     -14026.968     -14026.968      254.14637      254.14637      47730.025      47730.025      966.86952      966.86952    
Loop time of 501.086 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.172 ns/day, 139.191 hours/ns, 1.996 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    | 500.1      | 500.1      | 500.1      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15101    | 0.15101    | 0.15101    |   0.0 |  0.03
Output  | 0.0002402  | 0.0002402  | 0.0002402  |   0.0 |  0.00
Modify  | 0.73386    | 0.73386    | 0.73386    |   0.0 |  0.15
Other   |            | 0.09932    |            |       |  0.02

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

Total # of neighbors = 532978
Ave neighs/atom = 133.2445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.483197791891, Press = -1.04664676894334
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13895.597     -13895.597     -14026.968     -14026.968      254.14637      254.14637      47730.025      47730.025      966.86952      966.86952    
     54000  -13895.183     -13895.183     -14025.353     -14025.353      251.82224      251.82224      47809.242      47809.242     -926.27615     -926.27615    
Loop time of 503.307 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.172 ns/day, 139.808 hours/ns, 1.987 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    | 502.31     | 502.31     | 502.31     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15094    | 0.15094    | 0.15094    |   0.0 |  0.03
Output  | 0.0001908  | 0.0001908  | 0.0001908  |   0.0 |  0.00
Modify  | 0.73964    | 0.73964    | 0.73964    |   0.0 |  0.15
Other   |            | 0.102      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533174 ave      533174 max      533174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533174
Ave neighs/atom = 133.2935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.49439902155, Press = 0.367984588229245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13895.183     -13895.183     -14025.353     -14025.353      251.82224      251.82224      47809.242      47809.242     -926.27615     -926.27615    
     55000  -13896.157     -13896.157     -14027.903     -14027.903      254.87248      254.87248      47740.4        47740.4        651.1534       651.1534     
Loop time of 507.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 140.880 hours/ns, 1.972 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    | 506.16     | 506.16     | 506.16     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15213    | 0.15213    | 0.15213    |   0.0 |  0.03
Output  | 0.00023565 | 0.00023565 | 0.00023565 |   0.0 |  0.00
Modify  | 0.75029    | 0.75029    | 0.75029    |   0.0 |  0.15
Other   |            | 0.1005     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       532640 ave      532640 max      532640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532640
Ave neighs/atom = 133.16
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.489437429659, Press = -0.268889558264444
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13896.157     -13896.157     -14027.903     -14027.903      254.87248      254.87248      47740.4        47740.4        651.1534       651.1534     
     56000  -13899.117     -13899.117     -14028.803     -14028.803      250.88585      250.88585      47779.88       47779.88      -482.0758      -482.0758     
Loop time of 508.291 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.192 hours/ns, 1.967 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    | 507.28     | 507.28     | 507.28     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15189    | 0.15189    | 0.15189    |   0.0 |  0.03
Output  | 0.00019205 | 0.00019205 | 0.00019205 |   0.0 |  0.00
Modify  | 0.75218    | 0.75218    | 0.75218    |   0.0 |  0.15
Other   |            | 0.1017     |            |       |  0.02

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

Total # of neighbors = 533270
Ave neighs/atom = 133.3175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.445791429839, Press = -0.292559806873748
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13899.117     -13899.117     -14028.803     -14028.803      250.88585      250.88585      47779.88       47779.88      -482.0758      -482.0758     
     57000  -13897.034     -13897.034     -14026.313     -14026.313      250.09776      250.09776      47746.58       47746.58       574.63744      574.63744    
Loop time of 516.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.167 ns/day, 143.545 hours/ns, 1.935 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    | 515.74     | 515.74     | 515.74     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15467    | 0.15467    | 0.15467    |   0.0 |  0.03
Output  | 0.00025593 | 0.00025593 | 0.00025593 |   0.0 |  0.00
Modify  | 0.7679     | 0.7679     | 0.7679     |   0.0 |  0.15
Other   |            | 0.1014     |            |       |  0.02

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

Total # of neighbors = 533278
Ave neighs/atom = 133.3195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.453597264258, Press = -0.164171947009397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13897.034     -13897.034     -14026.313     -14026.313      250.09776      250.09776      47746.58       47746.58       574.63744      574.63744    
     58000  -13895.486     -13895.486     -14025.965     -14025.965      252.42119      252.42119      47771.96       47771.96       22.248659      22.248659    
Loop time of 510.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 141.762 hours/ns, 1.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    | 509.33     | 509.33     | 509.33     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15259    | 0.15259    | 0.15259    |   0.0 |  0.03
Output  | 0.00018898 | 0.00018898 | 0.00018898 |   0.0 |  0.00
Modify  | 0.75506    | 0.75506    | 0.75506    |   0.0 |  0.15
Other   |            | 0.1017     |            |       |  0.02

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

Total # of neighbors = 533234
Ave neighs/atom = 133.3085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.45919294502, Press = -0.28751947505854
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13895.486     -13895.486     -14025.965     -14025.965      252.42119      252.42119      47771.96       47771.96       22.248659      22.248659    
     59000  -13902.886     -13902.886     -14029.909     -14029.909      245.73562      245.73562      47756.802      47756.802     -79.322925     -79.322925    
Loop time of 506.749 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 140.764 hours/ns, 1.973 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    | 505.75     | 505.75     | 505.75     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1517     | 0.1517     | 0.1517     |   0.0 |  0.03
Output  | 0.00019329 | 0.00019329 | 0.00019329 |   0.0 |  0.00
Modify  | 0.74228    | 0.74228    | 0.74228    |   0.0 |  0.15
Other   |            | 0.1004     |            |       |  0.02

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

Total # of neighbors = 533156
Ave neighs/atom = 133.289
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.458951796071, Press = -0.100617524044033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13902.886     -13902.886     -14029.909     -14029.909      245.73562      245.73562      47756.802      47756.802     -79.322925     -79.322925    
     60000  -13894.394     -13894.394     -14029.279     -14029.279      260.94312      260.94312      47760.747      47760.747      91.788246      91.788246    
Loop time of 503.975 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 139.993 hours/ns, 1.984 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    | 502.98     | 502.98     | 502.98     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15125    | 0.15125    | 0.15125    |   0.0 |  0.03
Output  | 0.00018794 | 0.00018794 | 0.00018794 |   0.0 |  0.00
Modify  | 0.74098    | 0.74098    | 0.74098    |   0.0 |  0.15
Other   |            | 0.1001     |            |       |  0.02

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

Total # of neighbors = 533342
Ave neighs/atom = 133.3355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.426248868727, Press = -0.402730302197381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13894.394     -13894.394     -14029.279     -14029.279      260.94312      260.94312      47760.747      47760.747      91.788246      91.788246    
     61000  -13900.436     -13900.436     -14028.202     -14028.202      247.172        247.172        47823.214      47823.214     -1590.2604     -1590.2604    
Loop time of 510.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.169 ns/day, 141.883 hours/ns, 1.958 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    | 509.77     | 509.77     | 509.77     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15261    | 0.15261    | 0.15261    |   0.0 |  0.03
Output  | 0.00019293 | 0.00019293 | 0.00019293 |   0.0 |  0.00
Modify  | 0.75514    | 0.75514    | 0.75514    |   0.0 |  0.15
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533208 ave      533208 max      533208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533208
Ave neighs/atom = 133.302
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.403340194113, Press = -0.564862879561219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13900.436     -13900.436     -14028.202     -14028.202      247.172        247.172        47823.214      47823.214     -1590.2604     -1590.2604    
     62000  -13894.264     -13894.264     -14026.599     -14026.599      256.00918      256.00918      47698.788      47698.788      1836.4645      1836.4645    
Loop time of 509.286 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.468 hours/ns, 1.964 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    | 508.28     | 508.28     | 508.28     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15265    | 0.15265    | 0.15265    |   0.0 |  0.03
Output  | 0.00019182 | 0.00019182 | 0.00019182 |   0.0 |  0.00
Modify  | 0.75522    | 0.75522    | 0.75522    |   0.0 |  0.15
Other   |            | 0.1011     |            |       |  0.02

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

Total # of neighbors = 532832
Ave neighs/atom = 133.208
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.380574721214, Press = 0.74720358218992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13894.264     -13894.264     -14026.599     -14026.599      256.00918      256.00918      47698.788      47698.788      1836.4645      1836.4645    
     63000  -13897.601     -13897.601     -14027.518     -14027.518      251.33203      251.33203      47764.533      47764.533     -8.7993409     -8.7993409    
Loop time of 509.261 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.461 hours/ns, 1.964 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    | 508.26     | 508.26     | 508.26     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15176    | 0.15176    | 0.15176    |   0.0 |  0.03
Output  | 0.00018788 | 0.00018788 | 0.00018788 |   0.0 |  0.00
Modify  | 0.75335    | 0.75335    | 0.75335    |   0.0 |  0.15
Other   |            | 0.101      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533262 ave      533262 max      533262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533262
Ave neighs/atom = 133.3155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.355366134542, Press = -0.788829499112461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13897.601     -13897.601     -14027.518     -14027.518      251.33203      251.33203      47764.533      47764.533     -8.7993409     -8.7993409    
     64000  -13897.766     -13897.766     -14024.682     -14024.682      245.52704      245.52704      47787.527      47787.527     -433.96216     -433.96216    
Loop time of 503.533 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.172 ns/day, 139.870 hours/ns, 1.986 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    | 502.54     | 502.54     | 502.54     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15138    | 0.15138    | 0.15138    |   0.0 |  0.03
Output  | 0.00019125 | 0.00019125 | 0.00019125 |   0.0 |  0.00
Modify  | 0.73854    | 0.73854    | 0.73854    |   0.0 |  0.15
Other   |            | 0.1        |            |       |  0.02

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

Total # of neighbors = 533088
Ave neighs/atom = 133.272
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.364318922684, Press = 0.352575441343492
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13897.766     -13897.766     -14024.682     -14024.682      245.52704      245.52704      47787.527      47787.527     -433.96216     -433.96216    
     65000  -13892.088     -13892.088     -14024.64      -14024.64       256.43157      256.43157      47745.356      47745.356      809.62796      809.62796    
Loop time of 502.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.172 ns/day, 139.603 hours/ns, 1.990 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    | 501.57     | 501.57     | 501.57     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15138    | 0.15138    | 0.15138    |   0.0 |  0.03
Output  | 0.00028643 | 0.00028643 | 0.00028643 |   0.0 |  0.00
Modify  | 0.7466     | 0.7466     | 0.7466     |   0.0 |  0.15
Other   |            | 0.1003     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       532604 ave      532604 max      532604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532604
Ave neighs/atom = 133.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.371708838278, Press = -0.267842525705119
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13892.088     -13892.088     -14024.64      -14024.64       256.43157      256.43157      47745.356      47745.356      809.62796      809.62796    
     66000  -13895.616     -13895.616     -14026.727     -14026.727      253.64284      253.64284      47804.504      47804.504     -904.44066     -904.44066    
Loop time of 498.348 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.173 ns/day, 138.430 hours/ns, 2.007 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    | 497.36     | 497.36     | 497.36     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14934    | 0.14934    | 0.14934    |   0.0 |  0.03
Output  | 0.00019028 | 0.00019028 | 0.00019028 |   0.0 |  0.00
Modify  | 0.73395    | 0.73395    | 0.73395    |   0.0 |  0.15
Other   |            | 0.09999    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       532988 ave      532988 max      532988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532988
Ave neighs/atom = 133.247
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.381697289723, Press = -0.227100026663491
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13895.616     -13895.616     -14026.727     -14026.727      253.64284      253.64284      47804.504      47804.504     -904.44066     -904.44066    
     67000  -13896.088     -13896.088     -14025.926     -14025.926      251.18134      251.18134      47745.742      47745.742      652.32579      652.32579    
Loop time of 504.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.231 hours/ns, 1.981 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    | 503.85     | 503.85     | 503.85     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14973    | 0.14973    | 0.14973    |   0.0 |  0.03
Output  | 0.00019234 | 0.00019234 | 0.00019234 |   0.0 |  0.00
Modify  | 0.73719    | 0.73719    | 0.73719    |   0.0 |  0.15
Other   |            | 0.09956    |            |       |  0.02

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

Total # of neighbors = 532800
Ave neighs/atom = 133.2
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.392749704128, Press = 0.101609577984451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13896.088     -13896.088     -14025.926     -14025.926      251.18134      251.18134      47745.742      47745.742      652.32579      652.32579    
     68000  -13898.387     -13898.387     -14028.201     -14028.201      251.13475      251.13475      47762.598      47762.598     -15.474223     -15.474223    
Loop time of 508.225 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.170 ns/day, 141.174 hours/ns, 1.968 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    | 507.23     | 507.23     | 507.23     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15135    | 0.15135    | 0.15135    |   0.0 |  0.03
Output  | 0.00019077 | 0.00019077 | 0.00019077 |   0.0 |  0.00
Modify  | 0.74602    | 0.74602    | 0.74602    |   0.0 |  0.15
Other   |            | 0.09992    |            |       |  0.02

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

Total # of neighbors = 533122
Ave neighs/atom = 133.2805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.405467608876, Press = -0.312201820323674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13898.387     -13898.387     -14028.201     -14028.201      251.13475      251.13475      47762.598      47762.598     -15.474223     -15.474223    
     69000  -13895.794     -13895.794     -14027.095     -14027.095      254.01218      254.01218      47775.581      47775.581     -181.60552     -181.60552    
Loop time of 506.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.562 hours/ns, 1.976 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    | 505.03     | 505.03     | 505.03     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15213    | 0.15213    | 0.15213    |   0.0 |  0.03
Output  | 0.00024145 | 0.00024145 | 0.00024145 |   0.0 |  0.00
Modify  | 0.74088    | 0.74088    | 0.74088    |   0.0 |  0.15
Other   |            | 0.09963    |            |       |  0.02

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

Total # of neighbors = 533100
Ave neighs/atom = 133.275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.388685953828, Press = -0.0330308115747719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13895.794     -13895.794     -14027.095     -14027.095      254.01218      254.01218      47775.581      47775.581     -181.60552     -181.60552    
     70000  -13894.62      -13894.62      -14027.482     -14027.482      257.02924      257.02924      47756.206      47756.206      287.82611      287.82611    
Loop time of 496.912 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.174 ns/day, 138.031 hours/ns, 2.012 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    | 495.93     | 495.93     | 495.93     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1509     | 0.1509     | 0.1509     |   0.0 |  0.03
Output  | 0.00019201 | 0.00019201 | 0.00019201 |   0.0 |  0.00
Modify  | 0.72957    | 0.72957    | 0.72957    |   0.0 |  0.15
Other   |            | 0.09928    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       533092 ave      533092 max      533092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533092
Ave neighs/atom = 133.273
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.374325561608, Press = -0.533188223831731
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13894.62      -13894.62      -14027.482     -14027.482      257.02924      257.02924      47756.206      47756.206      287.82611      287.82611    
     71000  -13895.041     -13895.041     -14026.451     -14026.451      254.21998      254.21998      47835.755      47835.755     -1665.8957     -1665.8957    
Loop time of 504.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.202 hours/ns, 1.981 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    | 503.73     | 503.73     | 503.73     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15175    | 0.15175    | 0.15175    |   0.0 |  0.03
Output  | 0.00019414 | 0.00019414 | 0.00019414 |   0.0 |  0.00
Modify  | 0.74693    | 0.74693    | 0.74693    |   0.0 |  0.15
Other   |            | 0.1005     |            |       |  0.02

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

Total # of neighbors = 532924
Ave neighs/atom = 133.231
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.371055983134, Press = 0.310272423475577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13895.041     -13895.041     -14026.451     -14026.451      254.21998      254.21998      47835.755      47835.755     -1665.8957     -1665.8957    
     72000  -13899.205     -13899.205     -14028.459     -14028.459      250.0499       250.0499       47702.784      47702.784      1504.621       1504.621     
Loop time of 506.7 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.750 hours/ns, 1.974 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    | 505.7      | 505.7      | 505.7      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15131    | 0.15131    | 0.15131    |   0.0 |  0.03
Output  | 0.00019702 | 0.00019702 | 0.00019702 |   0.0 |  0.00
Modify  | 0.7442     | 0.7442     | 0.7442     |   0.0 |  0.15
Other   |            | 0.1005     |            |       |  0.02

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

Total # of neighbors = 532868
Ave neighs/atom = 133.217
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.344433413433, Press = -0.204903581154193
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13899.205     -13899.205     -14028.459     -14028.459      250.0499       250.0499       47702.784      47702.784      1504.621       1504.621     
     73000  -13898.349     -13898.349     -14027.964     -14027.964      250.75005      250.75005      47806.964      47806.964     -1140.7891     -1140.7891    
Loop time of 505.406 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 140.391 hours/ns, 1.979 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    | 504.41     | 504.41     | 504.41     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15155    | 0.15155    | 0.15155    |   0.0 |  0.03
Output  | 0.00023462 | 0.00023462 | 0.00023462 |   0.0 |  0.00
Modify  | 0.7422     | 0.7422     | 0.7422     |   0.0 |  0.15
Other   |            | 0.1001     |            |       |  0.02

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

Total # of neighbors = 533574
Ave neighs/atom = 133.3935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.339984500381, Press = -0.324279097662517
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13898.349     -13898.349     -14027.964     -14027.964      250.75005      250.75005      47806.964      47806.964     -1140.7891     -1140.7891    
     74000  -13892.053     -13892.053     -14022.61      -14022.61       252.57149      252.57149      47757.852      47757.852      702.80753      702.80753    
Loop time of 503.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.171 ns/day, 139.953 hours/ns, 1.985 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    | 502.84     | 502.84     | 502.84     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1501     | 0.1501     | 0.1501     |   0.0 |  0.03
Output  | 0.00018998 | 0.00018998 | 0.00018998 |   0.0 |  0.00
Modify  | 0.74044    | 0.74044    | 0.74044    |   0.0 |  0.15
Other   |            | 0.09935    |            |       |  0.02

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

Total # of neighbors = 533044
Ave neighs/atom = 133.261
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
47770.3309755691

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0