# 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.006 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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  -36509.899     -36509.899     -36854.36      -36854.36       333.15         333.15         160151.28      160151.28      2297.3495      2297.3495    
      1000  -36116.69      -36116.69      -36460.865     -36460.865      332.87291      332.87291      158396.92      158396.92      214.4868       214.4868     
Loop time of 366.507 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.236 ns/day, 101.807 hours/ns, 2.728 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.81     | 364.81     | 364.81     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20377    | 0.20377    | 0.20377    |   0.0 |  0.06
Output  | 0.00036631 | 0.00036631 | 0.00036631 |   0.0 |  0.00
Modify  | 1.3284     | 1.3284     | 1.3284     |   0.0 |  0.36
Other   |            | 0.161      |            |       |  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  -36116.69      -36116.69      -36460.865     -36460.865      332.87291      332.87291      158396.92      158396.92      214.4868       214.4868     
      2000  -36154.409     -36154.409     -36494.263     -36494.263      328.69438      328.69438      158520.25      158520.25      407.17252      407.17252    
Loop time of 370.572 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 102.937 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.88     | 368.88     | 368.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20255    | 0.20255    | 0.20255    |   0.0 |  0.05
Output  | 0.0002749  | 0.0002749  | 0.0002749  |   0.0 |  0.00
Modify  | 1.3241     | 1.3241     | 1.3241     |   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:       390912 ave      390912 max      390912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390912
Ave neighs/atom = 48.864
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -36154.409     -36154.409     -36494.263     -36494.263      328.69438      328.69438      158520.25      158520.25      407.17252      407.17252    
      3000  -36128.334     -36128.334     -36477.266     -36477.266      337.4745       337.4745       158366.17      158366.17      230.80921      230.80921    
Loop time of 372.584 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.496 hours/ns, 2.684 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.88     | 370.88     | 370.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20676    | 0.20676    | 0.20676    |   0.0 |  0.06
Output  | 0.00027714 | 0.00027714 | 0.00027714 |   0.0 |  0.00
Modify  | 1.3372     | 1.3372     | 1.3372     |   0.0 |  0.36
Other   |            | 0.1635     |            |       |  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:       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 = 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  -36128.334     -36128.334     -36477.266     -36477.266      337.4745       337.4745       158366.17      158366.17      230.80921      230.80921    
      4000  -36150.224     -36150.224     -36488.52      -36488.52       327.18736      327.18736      158532.74      158532.74     -46.137569     -46.137569    
Loop time of 371.908 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.308 hours/ns, 2.689 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.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20551    | 0.20551    | 0.20551    |   0.0 |  0.06
Output  | 0.00032311 | 0.00032311 | 0.00032311 |   0.0 |  0.00
Modify  | 1.3389     | 1.3389     | 1.3389     |   0.0 |  0.36
Other   |            | 0.1634     |            |       |  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:       391102 ave      391102 max      391102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 391102
Ave neighs/atom = 48.88775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -36150.224     -36150.224     -36488.52      -36488.52       327.18736      327.18736      158532.74      158532.74     -46.137569     -46.137569    
      5000  -36130.67      -36130.67      -36477.46      -36477.46       335.40258      335.40258      158328.01      158328.01      645.84298      645.84298    
Loop time of 371.574 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.215 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.86     | 369.86     | 369.86     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20735    | 0.20735    | 0.20735    |   0.0 |  0.06
Output  | 0.00023021 | 0.00023021 | 0.00023021 |   0.0 |  0.00
Modify  | 1.3422     | 1.3422     | 1.3422     |   0.0 |  0.36
Other   |            | 0.1634     |            |       |  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:       389076 ave      389076 max      389076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389076
Ave neighs/atom = 48.6345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 335.453379643693, Press = 34.113495583191
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36130.67      -36130.67      -36477.46      -36477.46       335.40258      335.40258      158328.01      158328.01      645.84298      645.84298    
      6000  -36148.109     -36148.109     -36485.973     -36485.973      326.76984      326.76984      158430.17      158430.17      191.22865      191.22865    
Loop time of 371.602 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.223 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.86     | 369.86     | 369.86     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20566    | 0.20566    | 0.20566    |   0.0 |  0.06
Output  | 0.00023228 | 0.00023228 | 0.00023228 |   0.0 |  0.00
Modify  | 1.3734     | 1.3734     | 1.3734     |   0.0 |  0.37
Other   |            | 0.1624     |            |       |  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:       390598 ave      390598 max      390598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390598
Ave neighs/atom = 48.82475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.531502100239, Press = -29.1257771087336
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36148.109     -36148.109     -36485.973     -36485.973      326.76984      326.76984      158430.17      158430.17      191.22865      191.22865    
      7000  -36132.554     -36132.554     -36482.052     -36482.052      338.02153      338.02153      158464.38      158464.38      263.33027      263.33027    
Loop time of 371.932 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.314 hours/ns, 2.689 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.19     | 370.19     | 370.19     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20662    | 0.20662    | 0.20662    |   0.0 |  0.06
Output  | 0.00023509 | 0.00023509 | 0.00023509 |   0.0 |  0.00
Modify  | 1.3704     | 1.3704     | 1.3704     |   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:       390002 ave      390002 max      390002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390002
Ave neighs/atom = 48.75025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.262596877785, Press = -9.8783022001741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36132.554     -36132.554     -36482.052     -36482.052      338.02153      338.02153      158464.38      158464.38      263.33027      263.33027    
      8000  -36145.837     -36145.837     -36485.574     -36485.574      328.58133      328.58133      158503.67      158503.67     -335.31889     -335.31889    
Loop time of 372.745 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.540 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    | 371        | 371        | 371        |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20539    | 0.20539    | 0.20539    |   0.0 |  0.06
Output  | 0.0002814  | 0.0002814  | 0.0002814  |   0.0 |  0.00
Modify  | 1.3707     | 1.3707     | 1.3707     |   0.0 |  0.37
Other   |            | 0.1633     |            |       |  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:       389678 ave      389678 max      389678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389678
Ave neighs/atom = 48.70975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.274374440221, Press = -10.6896024112417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36145.837     -36145.837     -36485.574     -36485.574      328.58133      328.58133      158503.67      158503.67     -335.31889     -335.31889    
      9000  -36134.024     -36134.024     -36481.121     -36481.121      335.69893      335.69893      158583.93      158583.93     -473.37746     -473.37746    
Loop time of 371.209 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.114 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.47     | 369.47     | 369.47     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20664    | 0.20664    | 0.20664    |   0.0 |  0.06
Output  | 0.00023719 | 0.00023719 | 0.00023719 |   0.0 |  0.00
Modify  | 1.3712     | 1.3712     | 1.3712     |   0.0 |  0.37
Other   |            | 0.1629     |            |       |  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:       389844 ave      389844 max      389844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389844
Ave neighs/atom = 48.7305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.211051041792, Press = 2.89312028608976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36134.024     -36134.024     -36481.121     -36481.121      335.69893      335.69893      158583.93      158583.93     -473.37746     -473.37746    
     10000  -36146.033     -36146.033     -36489.108     -36489.108      331.80892      331.80892      158470.84      158470.84      80.780313      80.780313    
Loop time of 371.035 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.3      | 369.3      | 369.3      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20511    | 0.20511    | 0.20511    |   0.0 |  0.06
Output  | 0.00024292 | 0.00024292 | 0.00024292 |   0.0 |  0.00
Modify  | 1.3679     | 1.3679     | 1.3679     |   0.0 |  0.37
Other   |            | 0.1621     |            |       |  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:       389170 ave      389170 max      389170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389170
Ave neighs/atom = 48.64625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.241238267713, Press = 1.3054811316074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36146.033     -36146.033     -36489.108     -36489.108      331.80892      331.80892      158470.84      158470.84      80.780313      80.780313    
     11000  -36131.684     -36131.684     -36479.15      -36479.15       336.05612      336.05612      158527.06      158527.06     -315.19341     -315.19341    
Loop time of 372.939 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.594 hours/ns, 2.681 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.2      | 371.2      | 371.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20395    | 0.20395    | 0.20395    |   0.0 |  0.05
Output  | 0.00030469 | 0.00030469 | 0.00030469 |   0.0 |  0.00
Modify  | 1.3702     | 1.3702     | 1.3702     |   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:       389640 ave      389640 max      389640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389640
Ave neighs/atom = 48.705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.286846082914, Press = 0.812920694665733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36131.684     -36131.684     -36479.15      -36479.15       336.05612      336.05612      158527.06      158527.06     -315.19341     -315.19341    
     12000  -36143.378     -36143.378     -36489.483     -36489.483      334.73975      334.73975      158453.25      158453.25      164.50849      164.50849    
Loop time of 371.681 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.245 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.93     | 369.93     | 369.93     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20675    | 0.20675    | 0.20675    |   0.0 |  0.06
Output  | 0.00023804 | 0.00023804 | 0.00023804 |   0.0 |  0.00
Modify  | 1.378      | 1.378      | 1.378      |   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:           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:       389906 ave      389906 max      389906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389906
Ave neighs/atom = 48.73825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.336719935698, Press = 0.261331970455622
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36143.378     -36143.378     -36489.483     -36489.483      334.73975      334.73975      158453.25      158453.25      164.50849      164.50849    
     13000  -36135.994     -36135.994     -36480.808     -36480.808      333.49062      333.49062      158569.66      158569.66     -609.16344     -609.16344    
Loop time of 373.028 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.619 hours/ns, 2.681 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.28     | 371.28     | 371.28     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20389    | 0.20389    | 0.20389    |   0.0 |  0.05
Output  | 0.0002355  | 0.0002355  | 0.0002355  |   0.0 |  0.00
Modify  | 1.3799     | 1.3799     | 1.3799     |   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:           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:       389734 ave      389734 max      389734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389734
Ave neighs/atom = 48.71675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.437286463081, Press = -2.4247137831426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36135.994     -36135.994     -36480.808     -36480.808      333.49062      333.49062      158569.66      158569.66     -609.16344     -609.16344    
     14000  -36145.614     -36145.614     -36485.723     -36485.723      328.94079      328.94079      158652.13      158652.13     -932.37638     -932.37638    
Loop time of 373.739 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 103.816 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.98     | 371.98     | 371.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20553    | 0.20553    | 0.20553    |   0.0 |  0.05
Output  | 0.00024913 | 0.00024913 | 0.00024913 |   0.0 |  0.00
Modify  | 1.3894     | 1.3894     | 1.3894     |   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:       389656 ave      389656 max      389656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389656
Ave neighs/atom = 48.707
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.429443611171, Press = -1.19176442784172
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36145.614     -36145.614     -36485.723     -36485.723      328.94079      328.94079      158652.13      158652.13     -932.37638     -932.37638    
     15000  -36136.892     -36136.892     -36482.223     -36482.223      333.99089      333.99089      158486.77      158486.77     -197.9809      -197.9809     
Loop time of 373.212 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.670 hours/ns, 2.679 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.46     | 371.46     | 371.46     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20539    | 0.20539    | 0.20539    |   0.0 |  0.06
Output  | 0.00035532 | 0.00035532 | 0.00035532 |   0.0 |  0.00
Modify  | 1.3811     | 1.3811     | 1.3811     |   0.0 |  0.37
Other   |            | 0.1636     |            |       |  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:       389124 ave      389124 max      389124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389124
Ave neighs/atom = 48.6405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.264687778713, Press = 0.799027309303657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36136.892     -36136.892     -36482.223     -36482.223      333.99089      333.99089      158486.77      158486.77     -197.9809      -197.9809     
     16000  -36151.008     -36151.008     -36485.095     -36485.095      323.11656      323.11656      158387.87      158387.87      501.29749      501.29749    
Loop time of 372.645 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.512 hours/ns, 2.684 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.9      | 370.9      | 370.9      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20469    | 0.20469    | 0.20469    |   0.0 |  0.05
Output  | 0.00027712 | 0.00027712 | 0.00027712 |   0.0 |  0.00
Modify  | 1.377      | 1.377      | 1.377      |   0.0 |  0.37
Other   |            | 0.1643     |            |       |  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:       390000 ave      390000 max      390000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390000
Ave neighs/atom = 48.75
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.196733464773, Press = 0.315390505707277
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36151.008     -36151.008     -36485.095     -36485.095      323.11656      323.11656      158387.87      158387.87      501.29749      501.29749    
     17000  -36135.792     -36135.792     -36480.374     -36480.374      333.26643      333.26643      158425.71      158425.71      48.076355      48.076355    
Loop time of 373.054 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.626 hours/ns, 2.681 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.3      | 371.3      | 371.3      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20565    | 0.20565    | 0.20565    |   0.0 |  0.06
Output  | 0.00023739 | 0.00023739 | 0.00023739 |   0.0 |  0.00
Modify  | 1.3868     | 1.3868     | 1.3868     |   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:           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:       390072 ave      390072 max      390072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390072
Ave neighs/atom = 48.759
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.127993674821, Press = -0.498380191413928
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36135.792     -36135.792     -36480.374     -36480.374      333.26643      333.26643      158425.71      158425.71      48.076355      48.076355    
     18000  -36134.74      -36134.74      -36483.037     -36483.037      336.85987      336.85987      158406.54      158406.54      287.73333      287.73333    
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.89     | 369.89     | 369.89     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20366    | 0.20366    | 0.20366    |   0.0 |  0.05
Output  | 0.00029956 | 0.00029956 | 0.00029956 |   0.0 |  0.00
Modify  | 1.3715     | 1.3715     | 1.3715     |   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:           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:       390532 ave      390532 max      390532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390532
Ave neighs/atom = 48.8165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.153711807141, Press = -0.406156015846119
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36134.74      -36134.74      -36483.037     -36483.037      336.85987      336.85987      158406.54      158406.54      287.73333      287.73333    
     19000  -36132.768     -36132.768     -36482.622     -36482.622      338.3662       338.3662       158439.3       158439.3       133.37183      133.37183    
Loop time of 373.879 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 103.855 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.11     | 372.11     | 372.11     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2057     | 0.2057     | 0.2057     |   0.0 |  0.06
Output  | 0.00028825 | 0.00028825 | 0.00028825 |   0.0 |  0.00
Modify  | 1.3972     | 1.3972     | 1.3972     |   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:           6730 ave        6730 max        6730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       390508 ave      390508 max      390508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390508
Ave neighs/atom = 48.8135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.218257716052, Press = 1.06837710701848
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36132.768     -36132.768     -36482.622     -36482.622      338.3662       338.3662       158439.3       158439.3       133.37183      133.37183    
     20000  -36147.754     -36147.754     -36486.112     -36486.112      327.2473       327.2473       158279.18      158279.18      907.16324      907.16324    
Loop time of 370.91 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.031 hours/ns, 2.696 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.18     | 369.18     | 369.18     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20582    | 0.20582    | 0.20582    |   0.0 |  0.06
Output  | 0.00023925 | 0.00023925 | 0.00023925 |   0.0 |  0.00
Modify  | 1.3587     | 1.3587     | 1.3587     |   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:           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:       389978 ave      389978 max      389978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389978
Ave neighs/atom = 48.74725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.216644443002, Press = 1.10411269255695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36147.754     -36147.754     -36486.112     -36486.112      327.2473       327.2473       158279.18      158279.18      907.16324      907.16324    
     21000  -36139.662     -36139.662     -36480.448     -36480.448      329.59492      329.59492      158397.37      158397.37      72.793134      72.793134    
Loop time of 371.878 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.300 hours/ns, 2.689 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.13     | 370.13     | 370.13     |   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.00023061 | 0.00023061 | 0.00023061 |   0.0 |  0.00
Modify  | 1.3751     | 1.3751     | 1.3751     |   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:       390666 ave      390666 max      390666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390666
Ave neighs/atom = 48.83325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.144162981868, Press = -0.531511108912213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36139.662     -36139.662     -36480.448     -36480.448      329.59492      329.59492      158397.37      158397.37      72.793134      72.793134    
     22000  -36143.96      -36143.96      -36482.962     -36482.962      327.87064      327.87064      158480.61      158480.61     -200.8536      -200.8536     
Loop time of 373.057 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.627 hours/ns, 2.681 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.31     | 371.31     | 371.31     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20643    | 0.20643    | 0.20643    |   0.0 |  0.06
Output  | 0.00023063 | 0.00023063 | 0.00023063 |   0.0 |  0.00
Modify  | 1.3805     | 1.3805     | 1.3805     |   0.0 |  0.37
Other   |            | 0.1639     |            |       |  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:       390568 ave      390568 max      390568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 390568
Ave neighs/atom = 48.821
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.153247760708, Press = -1.18628406155347
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36143.96      -36143.96      -36482.962     -36482.962      327.87064      327.87064      158480.61      158480.61     -200.8536      -200.8536     
     23000  -36143.236     -36143.236     -36485.949     -36485.949      331.45885      331.45885      158612.57      158612.57     -480.3317      -480.3317     
Loop time of 372.174 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.382 hours/ns, 2.687 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.43     | 370.43     | 370.43     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20346    | 0.20346    | 0.20346    |   0.0 |  0.05
Output  | 0.00023794 | 0.00023794 | 0.00023794 |   0.0 |  0.00
Modify  | 1.3762     | 1.3762     | 1.3762     |   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:       389942 ave      389942 max      389942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 389942
Ave neighs/atom = 48.74275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.158889891265, Press = -1.59479223471582
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36143.236     -36143.236     -36485.949     -36485.949      331.45885      331.45885      158612.57      158612.57     -480.3317      -480.3317     
     24000  -36138.419     -36138.419     -36488.469     -36488.469      338.55576      338.55576      158614.8       158614.8      -429.68279     -429.68279    
Loop time of 371.715 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.254 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.97     | 369.97     | 369.97     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20468    | 0.20468    | 0.20468    |   0.0 |  0.06
Output  | 0.00023028 | 0.00023028 | 0.00023028 |   0.0 |  0.00
Modify  | 1.3748     | 1.3748     | 1.3748     |   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:           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:       388794 ave      388794 max      388794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388794
Ave neighs/atom = 48.59925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.067824358522, Press = 0.876004952031775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36138.419     -36138.419     -36488.469     -36488.469      338.55576      338.55576      158614.8       158614.8      -429.68279     -429.68279    
     25000  -36148.587     -36148.587     -36486.878     -36486.878      327.1825       327.1825       158594.16      158594.16     -475.28513     -475.28513    
Loop time of 372.044 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.346 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.3      | 370.3      | 370.3      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20304    | 0.20304    | 0.20304    |   0.0 |  0.05
Output  | 0.0002331  | 0.0002331  | 0.0002331  |   0.0 |  0.00
Modify  | 1.3742     | 1.3742     | 1.3742     |   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:           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:       388680 ave      388680 max      388680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388680
Ave neighs/atom = 48.585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.049202280846, Press = 0.554939045759651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36148.587     -36148.587     -36486.878     -36486.878      327.1825       327.1825       158594.16      158594.16     -475.28513     -475.28513    
     26000  -36140.292     -36140.292     -36480.832     -36480.832      329.35788      329.35788      158494.39      158494.39     -185.46487     -185.46487    
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.11     | 369.11     | 369.11     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20348    | 0.20348    | 0.20348    |   0.0 |  0.05
Output  | 0.0002345  | 0.0002345  | 0.0002345  |   0.0 |  0.00
Modify  | 1.3597     | 1.3597     | 1.3597     |   0.0 |  0.37
Other   |            | 0.163      |            |       |  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:       388906 ave      388906 max      388906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 388906
Ave neighs/atom = 48.61325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
158475.308610514

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0