# 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 5.430545687675476*${_u_distance}
variable latticeconst_converted equal 5.430545687675476*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.43054568767548
Lattice spacing in x,y,z = 5.4305457 5.4305457 5.4305457
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (54.305457 54.305457 54.305457)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0 0 0) to (54.305457 54.305457 54.305457)
  create_atoms CPU = 0.008 seconds

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

kim_interactions Si

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

kim interactions Si
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LenoskySadighAlonso_2000_Si__MO_533426548156_002
pair_coeff * * Si
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 28.0855

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.677 | 4.677 | 4.677 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -36530.578     -36530.578     -36854.36      -36854.36       313.15         313.15         160151.28      160151.28      2159.4321      2159.4321    
      1000  -36161.786     -36161.786     -36485.233     -36485.233      312.82654      312.82654      158487.35      158487.35      384.67539      384.67539    
Loop time of 366.317 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.236 ns/day, 101.755 hours/ns, 2.730 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 364.58     | 364.58     | 364.58     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21266    | 0.21266    | 0.21266    |   0.0 |  0.06
Output  | 0.00027641 | 0.00027641 | 0.00027641 |   0.0 |  0.00
Modify  | 1.3598     | 1.3598     | 1.3598     |   0.0 |  0.37
Other   |            | 0.1642     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       368000 ave      368000 max      368000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 368000
Ave neighs/atom = 46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -36161.786     -36161.786     -36485.233     -36485.233      312.82654      312.82654      158487.35      158487.35      384.67539      384.67539    
      2000  -36198.066     -36198.066     -36520.791     -36520.791      312.12719      312.12719      158705.55      158705.55      177.52487      177.52487    
Loop time of 370.255 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 102.849 hours/ns, 2.701 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.54     | 368.54     | 368.54     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20939    | 0.20939    | 0.20939    |   0.0 |  0.06
Output  | 0.0004074  | 0.0004074  | 0.0004074  |   0.0 |  0.00
Modify  | 1.3433     | 1.3433     | 1.3433     |   0.0 |  0.36
Other   |            | 0.1636     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388754 ave      388754 max      388754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388754
Ave neighs/atom = 48.59425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -36198.066     -36198.066     -36520.791     -36520.791      312.12719      312.12719      158705.55      158705.55      177.52487      177.52487    
      3000  -36172.554     -36172.554     -36497.42      -36497.42       314.19769      314.19769      158635.86      158635.86     -564.1114      -564.1114     
Loop time of 371.598 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.222 hours/ns, 2.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.88     | 369.88     | 369.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20871    | 0.20871    | 0.20871    |   0.0 |  0.06
Output  | 0.0002766  | 0.0002766  | 0.0002766  |   0.0 |  0.00
Modify  | 1.3478     | 1.3478     | 1.3478     |   0.0 |  0.36
Other   |            | 0.1642     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       385628 ave      385628 max      385628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385628
Ave neighs/atom = 48.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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -36172.554     -36172.554     -36497.42      -36497.42       314.19769      314.19769      158635.86      158635.86     -564.1114      -564.1114     
      4000  -36194.271     -36194.271     -36510.751     -36510.751      306.08782      306.08782      158617.15      158617.15      7.4093651      7.4093651    
Loop time of 369.693 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.234 ns/day, 102.692 hours/ns, 2.705 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 367.99     | 367.99     | 367.99     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20827    | 0.20827    | 0.20827    |   0.0 |  0.06
Output  | 0.00031024 | 0.00031024 | 0.00031024 |   0.0 |  0.00
Modify  | 1.3308     | 1.3308     | 1.3308     |   0.0 |  0.36
Other   |            | 0.1622     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388040 ave      388040 max      388040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.233 ns/day, 102.934 hours/ns, 2.699 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.84     | 368.84     | 368.84     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20869    | 0.20869    | 0.20869    |   0.0 |  0.06
Output  | 0.00024353 | 0.00024353 | 0.00024353 |   0.0 |  0.00
Modify  | 1.3479     | 1.3479     | 1.3479     |   0.0 |  0.36
Other   |            | 0.1631     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387160 ave      387160 max      387160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387160
Ave neighs/atom = 48.395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 317.244507330295, Press = 208.77266484089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -36175.008     -36175.008     -36507.201     -36507.201      321.28491      321.28491      158616.86      158616.86     -21.825777     -21.825777    
      6000  -36192         -36192         -36507.84      -36507.84       305.46883      305.46883      158527.16      158527.16      330.32482      330.32482    
Loop time of 371.753 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.265 hours/ns, 2.690 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.99     | 369.99     | 369.99     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21004    | 0.21004    | 0.21004    |   0.0 |  0.06
Output  | 0.00033024 | 0.00033024 | 0.00033024 |   0.0 |  0.00
Modify  | 1.391      | 1.391      | 1.391      |   0.0 |  0.37
Other   |            | 0.1651     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387654 ave      387654 max      387654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387654
Ave neighs/atom = 48.45675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.403854649765, Press = 12.0541968470154
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -36192         -36192         -36507.84      -36507.84       305.46883      305.46883      158527.16      158527.16      330.32482      330.32482    
      7000  -36177.123     -36177.123     -36503.78      -36503.78       315.93028      315.93028      158523.42      158523.42      244.47348      244.47348    
Loop time of 371.514 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.198 hours/ns, 2.692 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.76     | 369.76     | 369.76     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20875    | 0.20875    | 0.20875    |   0.0 |  0.06
Output  | 0.0002411  | 0.0002411  | 0.0002411  |   0.0 |  0.00
Modify  | 1.3775     | 1.3775     | 1.3775     |   0.0 |  0.37
Other   |            | 0.1637     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387806 ave      387806 max      387806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387806
Ave neighs/atom = 48.47575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.390291609459, Press = 8.87376886284526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -36177.123     -36177.123     -36503.78      -36503.78       315.93028      315.93028      158523.42      158523.42      244.47348      244.47348    
      8000  -36189.552     -36189.552     -36508.644     -36508.644      308.61354      308.61354      158511.5       158511.5       500.92863      500.92863    
Loop time of 372.289 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.414 hours/ns, 2.686 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.52     | 370.52     | 370.52     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21042    | 0.21042    | 0.21042    |   0.0 |  0.06
Output  | 0.00023363 | 0.00023363 | 0.00023363 |   0.0 |  0.00
Modify  | 1.3924     | 1.3924     | 1.3924     |   0.0 |  0.37
Other   |            | 0.1637     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388666 ave      388666 max      388666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388666
Ave neighs/atom = 48.58325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.204480486712, Press = 20.5462373949616
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -36189.552     -36189.552     -36508.644     -36508.644      308.61354      308.61354      158511.5       158511.5       500.92863      500.92863    
      9000  -36178.289     -36178.289     -36503.749     -36503.749      314.77273      314.77273      158674.65      158674.65     -616.99092     -616.99092    
Loop time of 370.84 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.011 hours/ns, 2.697 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.08     | 369.08     | 369.08     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20877    | 0.20877    | 0.20877    |   0.0 |  0.06
Output  | 0.00023868 | 0.00023868 | 0.00023868 |   0.0 |  0.00
Modify  | 1.3917     | 1.3917     | 1.3917     |   0.0 |  0.38
Other   |            | 0.1637     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387722 ave      387722 max      387722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387722
Ave neighs/atom = 48.46525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.278079849696, Press = 4.15607886250185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -36178.289     -36178.289     -36503.749     -36503.749      314.77273      314.77273      158674.65      158674.65     -616.99092     -616.99092    
     10000  -36188.602     -36188.602     -36508.667     -36508.667      309.55457      309.55457      158645.75      158645.75     -415.31465     -415.31465    
Loop time of 370.081 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 102.800 hours/ns, 2.702 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.33     | 368.33     | 368.33     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20849    | 0.20849    | 0.20849    |   0.0 |  0.06
Output  | 0.00023938 | 0.00023938 | 0.00023938 |   0.0 |  0.00
Modify  | 1.3816     | 1.3816     | 1.3816     |   0.0 |  0.37
Other   |            | 0.1635     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387786 ave      387786 max      387786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387786
Ave neighs/atom = 48.47325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.193823702663, Press = 3.40358994136944
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -36188.602     -36188.602     -36508.667     -36508.667      309.55457      309.55457      158645.75      158645.75     -415.31465     -415.31465    
     11000  -36179.71      -36179.71      -36506.943     -36506.943      316.48847      316.48847      158563.6       158563.6       3.7759167      3.7759167    
Loop time of 370.789 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 102.997 hours/ns, 2.697 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.04     | 369.04     | 369.04     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20824    | 0.20824    | 0.20824    |   0.0 |  0.06
Output  | 0.00023892 | 0.00023892 | 0.00023892 |   0.0 |  0.00
Modify  | 1.3781     | 1.3781     | 1.3781     |   0.0 |  0.37
Other   |            | 0.1623     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6727 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387434 ave      387434 max      387434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387434
Ave neighs/atom = 48.42925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.322619066539, Press = 2.71707379080116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -36179.71      -36179.71      -36506.943     -36506.943      316.48847      316.48847      158563.6       158563.6       3.7759167      3.7759167    
     12000  -36187.813     -36187.813     -36506.329     -36506.329      308.05617      308.05617      158623.73      158623.73     -204.32133     -204.32133    
Loop time of 371.033 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.065 hours/ns, 2.695 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.29     | 369.29     | 369.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20755    | 0.20755    | 0.20755    |   0.0 |  0.06
Output  | 0.00023586 | 0.00023586 | 0.00023586 |   0.0 |  0.00
Modify  | 1.3746     | 1.3746     | 1.3746     |   0.0 |  0.37
Other   |            | 0.1622     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388310 ave      388310 max      388310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388310
Ave neighs/atom = 48.53875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.242167877769, Press = 1.01442403726844
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -36187.813     -36187.813     -36506.329     -36506.329      308.05617      308.05617      158623.73      158623.73     -204.32133     -204.32133    
     13000  -36187.381     -36187.381     -36508.79      -36508.79       310.85463      310.85463      158597.14      158597.14      70.121786      70.121786    
Loop time of 371.666 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.241 hours/ns, 2.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.91     | 369.91     | 369.91     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20793    | 0.20793    | 0.20793    |   0.0 |  0.06
Output  | 0.00025828 | 0.00025828 | 0.00025828 |   0.0 |  0.00
Modify  | 1.3833     | 1.3833     | 1.3833     |   0.0 |  0.37
Other   |            | 0.1637     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387888 ave      387888 max      387888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387888
Ave neighs/atom = 48.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.244858186563, Press = 2.64394120575479
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -36187.381     -36187.381     -36508.79      -36508.79       310.85463      310.85463      158597.14      158597.14      70.121786      70.121786    
     14000  -36178.396     -36178.396     -36505.425     -36505.425      316.29009      316.29009      158740.12      158740.12     -627.59837     -627.59837    
Loop time of 371.427 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.174 hours/ns, 2.692 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.67     | 369.67     | 369.67     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21023    | 0.21023    | 0.21023    |   0.0 |  0.06
Output  | 0.00025419 | 0.00025419 | 0.00025419 |   0.0 |  0.00
Modify  | 1.3856     | 1.3856     | 1.3856     |   0.0 |  0.37
Other   |            | 0.1641     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387306 ave      387306 max      387306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387306
Ave neighs/atom = 48.41325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.237334170108, Press = 1.08161128272379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -36178.396     -36178.396     -36505.425     -36505.425      316.29009      316.29009      158740.12      158740.12     -627.59837     -627.59837    
     15000  -36186.784     -36186.784     -36508.914     -36508.914      311.55239      311.55239      158576.16      158576.16      187.06371      187.06371    
Loop time of 371.53 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.203 hours/ns, 2.692 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.77     | 369.77     | 369.77     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20873    | 0.20873    | 0.20873    |   0.0 |  0.06
Output  | 0.00029835 | 0.00029835 | 0.00029835 |   0.0 |  0.00
Modify  | 1.3845     | 1.3845     | 1.3845     |   0.0 |  0.37
Other   |            | 0.1637     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       386990 ave      386990 max      386990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386990
Ave neighs/atom = 48.37375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.329071001511, Press = -2.935422748888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -36186.784     -36186.784     -36508.914     -36508.914      311.55239      311.55239      158576.16      158576.16      187.06371      187.06371    
     16000  -36173.701     -36173.701     -36502.625     -36502.625      318.12352      318.12352      158493.56      158493.56      626.58373      626.58373    
Loop time of 372.712 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.531 hours/ns, 2.683 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.94     | 370.94     | 370.94     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21175    | 0.21175    | 0.21175    |   0.0 |  0.06
Output  | 0.0002435  | 0.0002435  | 0.0002435  |   0.0 |  0.00
Modify  | 1.4005     | 1.4005     | 1.4005     |   0.0 |  0.38
Other   |            | 0.164      |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387492 ave      387492 max      387492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387492
Ave neighs/atom = 48.4365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.380831335989, Press = -0.491698706483611
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -36173.701     -36173.701     -36502.625     -36502.625      318.12352      318.12352      158493.56      158493.56      626.58373      626.58373    
     17000  -36187.408     -36187.408     -36509.598     -36509.598      311.60995      311.60995      158563.92      158563.92      239.50179      239.50179    
Loop time of 373.377 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 103.716 hours/ns, 2.678 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.61     | 371.61     | 371.61     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20984    | 0.20984    | 0.20984    |   0.0 |  0.06
Output  | 0.00024243 | 0.00024243 | 0.00024243 |   0.0 |  0.00
Modify  | 1.3965     | 1.3965     | 1.3965     |   0.0 |  0.37
Other   |            | 0.1651     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387792 ave      387792 max      387792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387792
Ave neighs/atom = 48.474
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.428578883463, Press = -0.0942430469674674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -36187.408     -36187.408     -36509.598     -36509.598      311.60995      311.60995      158563.92      158563.92      239.50179      239.50179    
     18000  -36181.281     -36181.281     -36506.706     -36506.706      314.73899      314.73899      158419.3       158419.3       857.99954      857.99954    
Loop time of 371.959 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.322 hours/ns, 2.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.2      | 370.2      | 370.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20975    | 0.20975    | 0.20975    |   0.0 |  0.06
Output  | 0.00023271 | 0.00023271 | 0.00023271 |   0.0 |  0.00
Modify  | 1.3857     | 1.3857     | 1.3857     |   0.0 |  0.37
Other   |            | 0.1632     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6728 ave        6728 max        6728 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387552 ave      387552 max      387552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387552
Ave neighs/atom = 48.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.481181633186, Press = -0.204766924953365
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -36181.281     -36181.281     -36506.706     -36506.706      314.73899      314.73899      158419.3       158419.3       857.99954      857.99954    
     19000  -36189.977     -36189.977     -36510.665     -36510.665      310.15719      310.15719      158430.03      158430.03      901.75853      901.75853    
Loop time of 371.632 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.231 hours/ns, 2.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.88     | 369.88     | 369.88     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20712    | 0.20712    | 0.20712    |   0.0 |  0.06
Output  | 0.000241   | 0.000241   | 0.000241   |   0.0 |  0.00
Modify  | 1.3847     | 1.3847     | 1.3847     |   0.0 |  0.37
Other   |            | 0.1644     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388434 ave      388434 max      388434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388434
Ave neighs/atom = 48.55425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.503520942668, Press = 0.0498208824285335
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -36189.977     -36189.977     -36510.665     -36510.665      310.15719      310.15719      158430.03      158430.03      901.75853      901.75853    
     20000  -36185.132     -36185.132     -36509.756     -36509.756      313.96502      313.96502      158467.1       158467.1       682.44664      682.44664    
Loop time of 372.025 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.340 hours/ns, 2.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.25     | 370.25     | 370.25     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20966    | 0.20966    | 0.20966    |   0.0 |  0.06
Output  | 0.00028932 | 0.00028932 | 0.00028932 |   0.0 |  0.00
Modify  | 1.3972     | 1.3972     | 1.3972     |   0.0 |  0.38
Other   |            | 0.1639     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6727 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388066 ave      388066 max      388066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388066
Ave neighs/atom = 48.50825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.428731975246, Press = 0.104978577690694
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -36185.132     -36185.132     -36509.756     -36509.756      313.96502      313.96502      158467.1       158467.1       682.44664      682.44664    
     21000  -36188.767     -36188.767     -36512.703     -36512.703      313.29849      313.29849      158607.64      158607.64      178.7061       178.7061     
Loop time of 369.76 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.234 ns/day, 102.711 hours/ns, 2.704 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.01     | 368.01     | 368.01     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20864    | 0.20864    | 0.20864    |   0.0 |  0.06
Output  | 0.00024615 | 0.00024615 | 0.00024615 |   0.0 |  0.00
Modify  | 1.3819     | 1.3819     | 1.3819     |   0.0 |  0.37
Other   |            | 0.1628     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6727 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388222 ave      388222 max      388222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388222
Ave neighs/atom = 48.52775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.385330639818, Press = 0.521058036513959
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -36188.767     -36188.767     -36512.703     -36512.703      313.29849      313.29849      158607.64      158607.64      178.7061       178.7061     
     22000  -36178.687     -36178.687     -36507.585     -36507.585      318.09784      318.09784      158591.52      158591.52     -145.41314     -145.41314    
Loop time of 372.446 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.457 hours/ns, 2.685 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.68     | 370.68     | 370.68     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20991    | 0.20991    | 0.20991    |   0.0 |  0.06
Output  | 0.00024084 | 0.00024084 | 0.00024084 |   0.0 |  0.00
Modify  | 1.393      | 1.393      | 1.393      |   0.0 |  0.37
Other   |            | 0.164      |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6727 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387304 ave      387304 max      387304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387304
Ave neighs/atom = 48.413
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.433863026178, Press = 1.04381717338081
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -36178.687     -36178.687     -36507.585     -36507.585      318.09784      318.09784      158591.52      158591.52     -145.41314     -145.41314    
     23000  -36189.537     -36189.537     -36511.993     -36511.993      311.86761      311.86761      158540.69      158540.69      145.60037      145.60037    
Loop time of 371.34 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.150 hours/ns, 2.693 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.59     | 369.59     | 369.59     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20783    | 0.20783    | 0.20783    |   0.0 |  0.06
Output  | 0.00024185 | 0.00024185 | 0.00024185 |   0.0 |  0.00
Modify  | 1.3822     | 1.3822     | 1.3822     |   0.0 |  0.37
Other   |            | 0.1628     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388210 ave      388210 max      388210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388210
Ave neighs/atom = 48.52625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.408828970709, Press = 0.848627598758532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -36189.537     -36189.537     -36511.993     -36511.993      311.86761      311.86761      158540.69      158540.69      145.60037      145.60037    
     24000  -36185.862     -36185.862     -36507.092     -36507.092      310.6819       310.6819       158532.39      158532.39      59.849706      59.849706    
Loop time of 373.123 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.645 hours/ns, 2.680 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.37     | 371.37     | 371.37     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20864    | 0.20864    | 0.20864    |   0.0 |  0.06
Output  | 0.00029116 | 0.00029116 | 0.00029116 |   0.0 |  0.00
Modify  | 1.3848     | 1.3848     | 1.3848     |   0.0 |  0.37
Other   |            | 0.1618     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388140 ave      388140 max      388140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388140
Ave neighs/atom = 48.5175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.419800567963, Press = 1.0826146996727
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -36185.862     -36185.862     -36507.092     -36507.092      310.6819       310.6819       158532.39      158532.39      59.849706      59.849706    
     25000  -36183.178     -36183.178     -36508.489     -36508.489      314.62887      314.62887      158602.53      158602.53     -215.0566      -215.0566     
Loop time of 369.913 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.234 ns/day, 102.754 hours/ns, 2.703 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.17     | 368.17     | 368.17     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20739    | 0.20739    | 0.20739    |   0.0 |  0.06
Output  | 0.00028087 | 0.00028087 | 0.00028087 |   0.0 |  0.00
Modify  | 1.3734     | 1.3734     | 1.3734     |   0.0 |  0.37
Other   |            | 0.1627     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388330 ave      388330 max      388330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388330
Ave neighs/atom = 48.54125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.466585746855, Press = 0.0357405496169797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -36183.178     -36183.178     -36508.489     -36508.489      314.62887      314.62887      158602.53      158602.53     -215.0566      -215.0566     
     26000  -36179.477     -36179.477     -36505.952     -36505.952      315.75453      315.75453      158634.85      158634.85     -196.86347     -196.86347    
Loop time of 369.933 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.234 ns/day, 102.759 hours/ns, 2.703 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.2      | 368.2      | 368.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20645    | 0.20645    | 0.20645    |   0.0 |  0.06
Output  | 0.00023815 | 0.00023815 | 0.00023815 |   0.0 |  0.00
Modify  | 1.3618     | 1.3618     | 1.3618     |   0.0 |  0.37
Other   |            | 0.1616     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6732 ave        6732 max        6732 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387718 ave      387718 max      387718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387718
Ave neighs/atom = 48.46475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.447662292298, Press = -0.260993047436675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -36179.477     -36179.477     -36505.952     -36505.952      315.75453      315.75453      158634.85      158634.85     -196.86347     -196.86347    
     27000  -36189.683     -36189.683     -36513.636     -36513.636      313.31474      313.31474      158666.35      158666.35     -198.72463     -198.72463    
Loop time of 373.086 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.635 hours/ns, 2.680 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.32     | 371.32     | 371.32     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2092     | 0.2092     | 0.2092     |   0.0 |  0.06
Output  | 0.00023092 | 0.00023092 | 0.00023092 |   0.0 |  0.00
Modify  | 1.3916     | 1.3916     | 1.3916     |   0.0 |  0.37
Other   |            | 0.1638     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387412 ave      387412 max      387412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387412
Ave neighs/atom = 48.4265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.394055461633, Press = 2.05502445641855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -36189.683     -36189.683     -36513.636     -36513.636      313.31474      313.31474      158666.35      158666.35     -198.72463     -198.72463    
     28000  -36180.33      -36180.33      -36507.415     -36507.415      316.34424      316.34424      158608.87      158608.87     -145.82385     -145.82385    
Loop time of 371.429 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.175 hours/ns, 2.692 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.67     | 369.67     | 369.67     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2073     | 0.2073     | 0.2073     |   0.0 |  0.06
Output  | 0.00023557 | 0.00023557 | 0.00023557 |   0.0 |  0.00
Modify  | 1.3867     | 1.3867     | 1.3867     |   0.0 |  0.37
Other   |            | 0.1623     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       386650 ave      386650 max      386650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386650
Ave neighs/atom = 48.33125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.324823724654, Press = 0.850442611100044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -36180.33      -36180.33      -36507.415     -36507.415      316.34424      316.34424      158608.87      158608.87     -145.82385     -145.82385    
     29000  -36184.348     -36184.348     -36506.222     -36506.222      311.3049       311.3049       158499.41      158499.41      239.21233      239.21233    
Loop time of 375.428 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.230 ns/day, 104.286 hours/ns, 2.664 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.63     | 373.63     | 373.63     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21062    | 0.21062    | 0.21062    |   0.0 |  0.06
Output  | 0.00035953 | 0.00035953 | 0.00035953 |   0.0 |  0.00
Modify  | 1.4203     | 1.4203     | 1.4203     |   0.0 |  0.38
Other   |            | 0.166      |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6729 ave        6729 max        6729 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387760 ave      387760 max      387760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387760
Ave neighs/atom = 48.47
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.301993851517, Press = 0.77148089262613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -36184.348     -36184.348     -36506.222     -36506.222      311.3049       311.3049       158499.41      158499.41      239.21233      239.21233    
     30000  -36181.771     -36181.771     -36508.295     -36508.295      315.8014       315.8014       158601.69      158601.69      44.368131      44.368131    
Loop time of 375.525 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.230 ns/day, 104.312 hours/ns, 2.663 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.73     | 373.73     | 373.73     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20898    | 0.20898    | 0.20898    |   0.0 |  0.06
Output  | 0.00037097 | 0.00037097 | 0.00037097 |   0.0 |  0.00
Modify  | 1.4168     | 1.4168     | 1.4168     |   0.0 |  0.38
Other   |            | 0.1654     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       388360 ave      388360 max      388360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388360
Ave neighs/atom = 48.545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.299610388262, Press = 0.525443325840899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -36181.771     -36181.771     -36508.295     -36508.295      315.8014       315.8014       158601.69      158601.69      44.368131      44.368131    
     31000  -36190.228     -36190.228     -36511.179     -36511.179      310.4121       310.4121       158717.8       158717.8      -601.62763     -601.62763    
Loop time of 373.691 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 103.803 hours/ns, 2.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.92     | 371.92     | 371.92     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20689    | 0.20689    | 0.20689    |   0.0 |  0.06
Output  | 0.00029096 | 0.00029096 | 0.00029096 |   0.0 |  0.00
Modify  | 1.398      | 1.398      | 1.398      |   0.0 |  0.37
Other   |            | 0.1642     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6727 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387482 ave      387482 max      387482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387482
Ave neighs/atom = 48.43525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.295339508363, Press = 1.40103473996953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -36190.228     -36190.228     -36511.179     -36511.179      310.4121       310.4121       158717.8       158717.8      -601.62763     -601.62763    
     32000  -36182.938     -36182.938     -36506.22      -36506.22       312.66574      312.66574      158721.9       158721.9      -984.50649     -984.50649    
Loop time of 374.567 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 104.046 hours/ns, 2.670 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.8      | 372.8      | 372.8      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20672    | 0.20672    | 0.20672    |   0.0 |  0.06
Output  | 0.00024031 | 0.00024031 | 0.00024031 |   0.0 |  0.00
Modify  | 1.4006     | 1.4006     | 1.4006     |   0.0 |  0.37
Other   |            | 0.1645     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387058 ave      387058 max      387058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387058
Ave neighs/atom = 48.38225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.256474988292, Press = 1.05160147501351
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -36182.938     -36182.938     -36506.22      -36506.22       312.66574      312.66574      158721.9       158721.9      -984.50649     -984.50649    
     33000  -36194.588     -36194.588     -36515.304     -36515.304      310.18483      310.18483      158604.44      158604.44     -7.4000986     -7.4000986    
Loop time of 373.816 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 103.838 hours/ns, 2.675 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.03     | 372.03     | 372.03     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20885    | 0.20885    | 0.20885    |   0.0 |  0.06
Output  | 0.00024479 | 0.00024479 | 0.00024479 |   0.0 |  0.00
Modify  | 1.4081     | 1.4081     | 1.4081     |   0.0 |  0.38
Other   |            | 0.165      |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6727 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387538 ave      387538 max      387538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387538
Ave neighs/atom = 48.44225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.199358116834, Press = 0.788956224675904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -36194.588     -36194.588     -36515.304     -36515.304      310.18483      310.18483      158604.44      158604.44     -7.4000986     -7.4000986    
     34000  -36180.93      -36180.93      -36509.094     -36509.094      317.38795      317.38795      158580.24      158580.24     -44.085991     -44.085991    
Loop time of 372.72 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.533 hours/ns, 2.683 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.95     | 370.95     | 370.95     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20771    | 0.20771    | 0.20771    |   0.0 |  0.06
Output  | 0.00028306 | 0.00028306 | 0.00028306 |   0.0 |  0.00
Modify  | 1.3965     | 1.3965     | 1.3965     |   0.0 |  0.37
Other   |            | 0.164      |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6726 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387174 ave      387174 max      387174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387174
Ave neighs/atom = 48.39675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.174667369779, Press = 0.335361583930801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -36180.93      -36180.93      -36509.094     -36509.094      317.38795      317.38795      158580.24      158580.24     -44.085991     -44.085991    
     35000  -36190.311     -36190.311     -36514.062     -36514.062      313.12026      313.12026      158642.47      158642.47     -211.48675     -211.48675    
Loop time of 375.797 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.230 ns/day, 104.388 hours/ns, 2.661 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 374        | 374        | 374        |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20931    | 0.20931    | 0.20931    |   0.0 |  0.06
Output  | 0.00023554 | 0.00023554 | 0.00023554 |   0.0 |  0.00
Modify  | 1.4201     | 1.4201     | 1.4201     |   0.0 |  0.38
Other   |            | 0.165      |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387720 ave      387720 max      387720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387720
Ave neighs/atom = 48.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.140422789918, Press = 0.46071344514652
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -36190.311     -36190.311     -36514.062     -36514.062      313.12026      313.12026      158642.47      158642.47     -211.48675     -211.48675    
     36000  -36182.528     -36182.528     -36504.777     -36504.777      311.66808      311.66808      158514.8       158514.8       174.20004      174.20004    
Loop time of 371.189 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.108 hours/ns, 2.694 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.44     | 369.44     | 369.44     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20403    | 0.20403    | 0.20403    |   0.0 |  0.05
Output  | 0.00024514 | 0.00024514 | 0.00024514 |   0.0 |  0.00
Modify  | 1.384      | 1.384      | 1.384      |   0.0 |  0.37
Other   |            | 0.1641     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6725 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       387166 ave      387166 max      387166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 387166
Ave neighs/atom = 48.39575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
158582.238769082

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0