# 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.427092507481575*${_u_distance}
variable latticeconst_converted equal 5.427092507481575*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.42709250748158
Lattice spacing in x,y,z = 5.4270925 5.4270925 5.4270925
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (54.270925 54.270925 54.270925)
  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.270925 54.270925 54.270925)
  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_Lee_2007_Si__MO_774917820956_001
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 159845.963304675    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 159845.963304675/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 159845.963304675/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 159845.963304675/(1*1*${_u_distance})
variable      V0_metal equal 159845.963304675/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 159845.963304675*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_774917820956_001#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  -36757.576     -36757.576     -37040         -37040          273.15         273.15         159845.96      159845.96      1887.2003      1887.2003    
      1000  -36450.913     -36450.913     -36755.507     -36755.507      294.5924       294.5924       160516.04      160516.04     -337.04923     -337.04923    
Loop time of 143.99 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.600 ns/day, 39.997 hours/ns, 6.945 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    | 142.32     | 142.32     | 142.32     |   0.0 | 98.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20038    | 0.20038    | 0.20038    |   0.0 |  0.14
Output  | 0.00029145 | 0.00029145 | 0.00029145 |   0.0 |  0.00
Modify  | 1.3082     | 1.3082     | 1.3082     |   0.0 |  0.91
Other   |            | 0.1606     |            |       |  0.11

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  -36450.913     -36450.913     -36755.507     -36755.507      294.5924       294.5924       160516.04      160516.04     -337.04923     -337.04923    
      2000  -36481.026     -36481.026     -36749.148     -36749.148      259.31753      259.31753      160503.89      160503.89     -264.04478     -264.04478    
Loop time of 164.948 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.524 ns/day, 45.819 hours/ns, 6.063 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 162.96     | 162.96     | 162.96     |   0.0 | 98.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22925    | 0.22925    | 0.22925    |   0.0 |  0.14
Output  | 0.00028535 | 0.00028535 | 0.00028535 |   0.0 |  0.00
Modify  | 1.5808     | 1.5808     | 1.5808     |   0.0 |  0.96
Other   |            | 0.1816     |            |       |  0.11

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

Total # of neighbors = 372558
Ave neighs/atom = 46.56975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -36481.026     -36481.026     -36749.148     -36749.148      259.31753      259.31753      160503.89      160503.89     -264.04478     -264.04478    
      3000  -36466.413     -36466.413     -36748.454     -36748.454      272.78005      272.78005      160427.92      160427.92      247.57569      247.57569    
Loop time of 145.035 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.596 ns/day, 40.288 hours/ns, 6.895 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.37     | 143.37     | 143.37     |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20473    | 0.20473    | 0.20473    |   0.0 |  0.14
Output  | 0.00028562 | 0.00028562 | 0.00028562 |   0.0 |  0.00
Modify  | 1.3        | 1.3        | 1.3        |   0.0 |  0.90
Other   |            | 0.159      |            |       |  0.11

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

Total # of neighbors = 372346
Ave neighs/atom = 46.54325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -36466.413     -36466.413     -36748.454     -36748.454      272.78005      272.78005      160427.92      160427.92      247.57569      247.57569    
      4000  -36473.134     -36473.134     -36755.064     -36755.064      272.67276      272.67276      160509.62      160509.62     -337.35843     -337.35843    
Loop time of 144.407 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.598 ns/day, 40.113 hours/ns, 6.925 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.75     | 142.75     | 142.75     |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20599    | 0.20599    | 0.20599    |   0.0 |  0.14
Output  | 0.00033055 | 0.00033055 | 0.00033055 |   0.0 |  0.00
Modify  | 1.2926     | 1.2926     | 1.2926     |   0.0 |  0.90
Other   |            | 0.1593     |            |       |  0.11

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

Total # of neighbors = 372752
Ave neighs/atom = 46.594
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -36473.134     -36473.134     -36755.064     -36755.064      272.67276      272.67276      160509.62      160509.62     -337.35843     -337.35843    
      5000  -36472.808     -36472.808     -36756.473     -36756.473      274.34988      274.34988      160545.5       160545.5      -626.37868     -626.37868    
Loop time of 143.668 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.601 ns/day, 39.908 hours/ns, 6.961 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.02     | 142.02     | 142.02     |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20374    | 0.20374    | 0.20374    |   0.0 |  0.14
Output  | 0.00024147 | 0.00024147 | 0.00024147 |   0.0 |  0.00
Modify  | 1.2879     | 1.2879     | 1.2879     |   0.0 |  0.90
Other   |            | 0.1584     |            |       |  0.11

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

Total # of neighbors = 372294
Ave neighs/atom = 46.53675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.956110788359, Press = -428.192328327475
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36472.808     -36472.808     -36756.473     -36756.473      274.34988      274.34988      160545.5       160545.5      -626.37868     -626.37868    
      6000  -36467.975     -36467.975     -36748.778     -36748.778      271.58253      271.58253      160333.94      160333.94      672.62122      672.62122    
Loop time of 166.562 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.519 ns/day, 46.267 hours/ns, 6.004 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 164.49     | 164.49     | 164.49     |   0.0 | 98.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23325    | 0.23325    | 0.23325    |   0.0 |  0.14
Output  | 0.00024999 | 0.00024999 | 0.00024999 |   0.0 |  0.00
Modify  | 1.6503     | 1.6503     | 1.6503     |   0.0 |  0.99
Other   |            | 0.1837     |            |       |  0.11

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

Total # of neighbors = 372394
Ave neighs/atom = 46.54925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.749140727159, Press = -19.5563768519375
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36467.975     -36467.975     -36748.778     -36748.778      271.58253      271.58253      160333.94      160333.94      672.62122      672.62122    
      7000  -36475.261     -36475.261     -36753.501     -36753.501      269.10395      269.10395      160492.63      160492.63     -266.24608     -266.24608    
Loop time of 144.215 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.599 ns/day, 40.060 hours/ns, 6.934 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.52     | 142.52     | 142.52     |   0.0 | 98.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20516    | 0.20516    | 0.20516    |   0.0 |  0.14
Output  | 0.00024875 | 0.00024875 | 0.00024875 |   0.0 |  0.00
Modify  | 1.3284     | 1.3284     | 1.3284     |   0.0 |  0.92
Other   |            | 0.1589     |            |       |  0.11

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

Total # of neighbors = 373132
Ave neighs/atom = 46.6415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.095899627594, Press = -2.43717130931009
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36475.261     -36475.261     -36753.501     -36753.501      269.10395      269.10395      160492.63      160492.63     -266.24608     -266.24608    
      8000  -36465.889     -36465.889     -36746.175     -36746.175      271.08278      271.08278      160521.51      160521.51     -314.63887     -314.63887    
Loop time of 150.532 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.574 ns/day, 41.814 hours/ns, 6.643 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.73     | 148.73     | 148.73     |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21306    | 0.21306    | 0.21306    |   0.0 |  0.14
Output  | 0.00024442 | 0.00024442 | 0.00024442 |   0.0 |  0.00
Modify  | 1.4178     | 1.4178     | 1.4178     |   0.0 |  0.94
Other   |            | 0.1667     |            |       |  0.11

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

Total # of neighbors = 372540
Ave neighs/atom = 46.5675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.084686132902, Press = -5.64353353283266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36465.889     -36465.889     -36746.175     -36746.175      271.08278      271.08278      160521.51      160521.51     -314.63887     -314.63887    
      9000  -36474.261     -36474.261     -36763.603     -36763.603      279.84112      279.84112      160408.42      160408.42      359.98864      359.98864    
Loop time of 167.013 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.517 ns/day, 46.393 hours/ns, 5.988 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 164.94     | 164.94     | 164.94     |   0.0 | 98.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2314     | 0.2314     | 0.2314     |   0.0 |  0.14
Output  | 0.00035407 | 0.00035407 | 0.00035407 |   0.0 |  0.00
Modify  | 1.6535     | 1.6535     | 1.6535     |   0.0 |  0.99
Other   |            | 0.1843     |            |       |  0.11

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

Total # of neighbors = 372374
Ave neighs/atom = 46.54675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.059006112314, Press = -5.51265193821556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36474.261     -36474.261     -36763.603     -36763.603      279.84112      279.84112      160408.42      160408.42      359.98864      359.98864    
     10000  -36469.104     -36469.104     -36755.368     -36755.368      276.86466      276.86466      160402.68      160402.68      425.51235      425.51235    
Loop time of 144.826 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.597 ns/day, 40.229 hours/ns, 6.905 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.12     | 143.12     | 143.12     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20755    | 0.20755    | 0.20755    |   0.0 |  0.14
Output  | 0.00024995 | 0.00024995 | 0.00024995 |   0.0 |  0.00
Modify  | 1.3397     | 1.3397     | 1.3397     |   0.0 |  0.93
Other   |            | 0.1597     |            |       |  0.11

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

Total # of neighbors = 371798
Ave neighs/atom = 46.47475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.168157458971, Press = 1.26499848531382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36469.104     -36469.104     -36755.368     -36755.368      276.86466      276.86466      160402.68      160402.68      425.51235      425.51235    
     11000  -36470.02      -36470.02      -36759.176     -36759.176      279.66117      279.66117      160583.38      160583.38     -625.70201     -625.70201    
Loop time of 166.119 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.520 ns/day, 46.144 hours/ns, 6.020 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 164.07     | 164.07     | 164.07     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23019    | 0.23019    | 0.23019    |   0.0 |  0.14
Output  | 0.00024613 | 0.00024613 | 0.00024613 |   0.0 |  0.00
Modify  | 1.6377     | 1.6377     | 1.6377     |   0.0 |  0.99
Other   |            | 0.1818     |            |       |  0.11

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

Total # of neighbors = 372326
Ave neighs/atom = 46.54075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.203575428609, Press = -1.62999906949034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36470.02      -36470.02      -36759.176     -36759.176      279.66117      279.66117      160583.38      160583.38     -625.70201     -625.70201    
     12000  -36469.572     -36469.572     -36760.808     -36760.808      281.6723       281.6723       160492.91      160492.91     -81.349965     -81.349965    
Loop time of 144.022 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.600 ns/day, 40.006 hours/ns, 6.943 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.34     | 142.34     | 142.34     |   0.0 | 98.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20502    | 0.20502    | 0.20502    |   0.0 |  0.14
Output  | 0.00024496 | 0.00024496 | 0.00024496 |   0.0 |  0.00
Modify  | 1.3217     | 1.3217     | 1.3217     |   0.0 |  0.92
Other   |            | 0.1584     |            |       |  0.11

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

Total # of neighbors = 371840
Ave neighs/atom = 46.48
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.416103791931, Press = -3.40477260166568
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36469.572     -36469.572     -36760.808     -36760.808      281.6723       281.6723       160492.91      160492.91     -81.349965     -81.349965    
     13000  -36473.073     -36473.073     -36758.405     -36758.405      275.96273      275.96273      160439.4       160439.4       210.37172      210.37172    
Loop time of 144.09 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.600 ns/day, 40.025 hours/ns, 6.940 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.4      | 142.4      | 142.4      |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2052     | 0.2052     | 0.2052     |   0.0 |  0.14
Output  | 0.00025218 | 0.00025218 | 0.00025218 |   0.0 |  0.00
Modify  | 1.3295     | 1.3295     | 1.3295     |   0.0 |  0.92
Other   |            | 0.1592     |            |       |  0.11

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

Total # of neighbors = 371776
Ave neighs/atom = 46.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.359287231743, Press = -2.3164254075614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36473.073     -36473.073     -36758.405     -36758.405      275.96273      275.96273      160439.4       160439.4       210.37172      210.37172    
     14000  -36473.225     -36473.225     -36759.128     -36759.128      276.51473      276.51473      160417.1       160417.1       287.94942      287.94942    
Loop time of 144.193 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.599 ns/day, 40.054 hours/ns, 6.935 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.5      | 142.5      | 142.5      |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20711    | 0.20711    | 0.20711    |   0.0 |  0.14
Output  | 0.00024659 | 0.00024659 | 0.00024659 |   0.0 |  0.00
Modify  | 1.3307     | 1.3307     | 1.3307     |   0.0 |  0.92
Other   |            | 0.1596     |            |       |  0.11

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

Total # of neighbors = 372090
Ave neighs/atom = 46.51125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.294818219128, Press = -1.70493104067534
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36473.225     -36473.225     -36759.128     -36759.128      276.51473      276.51473      160417.1       160417.1       287.94942      287.94942    
     15000  -36465.71      -36465.71      -36753.375     -36753.375      278.21891      278.21891      160457.77      160457.77      43.901863      43.901863    
Loop time of 144.173 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.599 ns/day, 40.048 hours/ns, 6.936 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.48     | 142.48     | 142.48     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20666    | 0.20666    | 0.20666    |   0.0 |  0.14
Output  | 0.00025504 | 0.00025504 | 0.00025504 |   0.0 |  0.00
Modify  | 1.3285     | 1.3285     | 1.3285     |   0.0 |  0.92
Other   |            | 0.1595     |            |       |  0.11

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

Total # of neighbors = 372134
Ave neighs/atom = 46.51675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.27156250036, Press = 0.311690625286921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36465.71      -36465.71      -36753.375     -36753.375      278.21891      278.21891      160457.77      160457.77      43.901863      43.901863    
     16000  -36468.047     -36468.047     -36749.591     -36749.591      272.29891      272.29891      160646.18      160646.18     -1122.19       -1122.19      
Loop time of 159.767 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.541 ns/day, 44.380 hours/ns, 6.259 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 157.8      | 157.8      | 157.8      |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22299    | 0.22299    | 0.22299    |   0.0 |  0.14
Output  | 0.00034022 | 0.00034022 | 0.00034022 |   0.0 |  0.00
Modify  | 1.5647     | 1.5647     | 1.5647     |   0.0 |  0.98
Other   |            | 0.1775     |            |       |  0.11

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

Total # of neighbors = 372366
Ave neighs/atom = 46.54575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.266388913338, Press = -0.477427501375859
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36468.047     -36468.047     -36749.591     -36749.591      272.29891      272.29891      160646.18      160646.18     -1122.19       -1122.19      
     17000  -36465.08      -36465.08      -36750.417     -36750.417      275.96762      275.96762      160497.82      160497.82     -167.50071     -167.50071    
Loop time of 149.009 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.580 ns/day, 41.391 hours/ns, 6.711 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.23     | 147.23     | 147.23     |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21472    | 0.21472    | 0.21472    |   0.0 |  0.14
Output  | 0.00031259 | 0.00031259 | 0.00031259 |   0.0 |  0.00
Modify  | 1.3957     | 1.3957     | 1.3957     |   0.0 |  0.94
Other   |            | 0.1655     |            |       |  0.11

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

Total # of neighbors = 372392
Ave neighs/atom = 46.549
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.273753863815, Press = -2.68429248490274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36465.08      -36465.08      -36750.417     -36750.417      275.96762      275.96762      160497.82      160497.82     -167.50071     -167.50071    
     18000  -36473.748     -36473.748     -36752.702     -36752.702      269.79393      269.79393      160359.86      160359.86      563.96341      563.96341    
Loop time of 144.353 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.599 ns/day, 40.098 hours/ns, 6.927 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.65     | 142.65     | 142.65     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21063    | 0.21063    | 0.21063    |   0.0 |  0.15
Output  | 0.00024696 | 0.00024696 | 0.00024696 |   0.0 |  0.00
Modify  | 1.3339     | 1.3339     | 1.3339     |   0.0 |  0.92
Other   |            | 0.1603     |            |       |  0.11

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

Total # of neighbors = 372498
Ave neighs/atom = 46.56225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.333032367848, Press = -0.902515829123254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36473.748     -36473.748     -36752.702     -36752.702      269.79393      269.79393      160359.86      160359.86      563.96341      563.96341    
     19000  -36469.567     -36469.567     -36754.017     -36754.017      275.10985      275.10985      160489.35      160489.35     -149.02099     -149.02099    
Loop time of 146.945 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.588 ns/day, 40.818 hours/ns, 6.805 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 145.2      | 145.2      | 145.2      |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21159    | 0.21159    | 0.21159    |   0.0 |  0.14
Output  | 0.00024962 | 0.00024962 | 0.00024962 |   0.0 |  0.00
Modify  | 1.3693     | 1.3693     | 1.3693     |   0.0 |  0.93
Other   |            | 0.1639     |            |       |  0.11

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

Total # of neighbors = 372916
Ave neighs/atom = 46.6145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.351483373069, Press = 0.447216557526911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36469.567     -36469.567     -36754.017     -36754.017      275.10985      275.10985      160489.35      160489.35     -149.02099     -149.02099    
     20000  -36477.957     -36477.957     -36757.366     -36757.366      270.23394      270.23394      160543.06      160543.06     -529.79864     -529.79864    
Loop time of 144.255 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.599 ns/day, 40.071 hours/ns, 6.932 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.55     | 142.55     | 142.55     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20889    | 0.20889    | 0.20889    |   0.0 |  0.14
Output  | 0.0002464  | 0.0002464  | 0.0002464  |   0.0 |  0.00
Modify  | 1.3347     | 1.3347     | 1.3347     |   0.0 |  0.93
Other   |            | 0.1602     |            |       |  0.11

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

Total # of neighbors = 372464
Ave neighs/atom = 46.558
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.263225201601, Press = -1.44259928355111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36477.957     -36477.957     -36757.366     -36757.366      270.23394      270.23394      160543.06      160543.06     -529.79864     -529.79864    
     21000  -36472.452     -36472.452     -36752.474     -36752.474      270.82703      270.82703      160416.78      160416.78      264.75203      264.75203    
Loop time of 144.244 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.599 ns/day, 40.068 hours/ns, 6.933 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.52     | 142.52     | 142.52     |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21403    | 0.21403    | 0.21403    |   0.0 |  0.15
Output  | 0.00026858 | 0.00026858 | 0.00026858 |   0.0 |  0.00
Modify  | 1.3468     | 1.3468     | 1.3468     |   0.0 |  0.93
Other   |            | 0.1615     |            |       |  0.11

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

Total # of neighbors = 372062
Ave neighs/atom = 46.50775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.254113063504, Press = -1.24080364172884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36472.452     -36472.452     -36752.474     -36752.474      270.82703      270.82703      160416.78      160416.78      264.75203      264.75203    
     22000  -36470.927     -36470.927     -36757.028     -36757.028      276.70596      276.70596      160439.58      160439.58      191.19636      191.19636    
Loop time of 144.16 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.599 ns/day, 40.044 hours/ns, 6.937 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    | 142.46     | 142.46     | 142.46     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2046     | 0.2046     | 0.2046     |   0.0 |  0.14
Output  | 0.00024103 | 0.00024103 | 0.00024103 |   0.0 |  0.00
Modify  | 1.3324     | 1.3324     | 1.3324     |   0.0 |  0.92
Other   |            | 0.1623     |            |       |  0.11

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

Total # of neighbors = 372486
Ave neighs/atom = 46.56075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.238769999839, Press = -0.425017478671718
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36470.927     -36470.927     -36757.028     -36757.028      276.70596      276.70596      160439.58      160439.58      191.19636      191.19636    
     23000  -36471.162     -36471.162     -36753.526     -36753.526      273.09139      273.09139      160496.7       160496.7      -220.95926     -220.95926    
Loop time of 166.762 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.518 ns/day, 46.323 hours/ns, 5.997 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 164.69     | 164.69     | 164.69     |   0.0 | 98.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23621    | 0.23621    | 0.23621    |   0.0 |  0.14
Output  | 0.0003009  | 0.0003009  | 0.0003009  |   0.0 |  0.00
Modify  | 1.65       | 1.65       | 1.65       |   0.0 |  0.99
Other   |            | 0.1834     |            |       |  0.11

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

Total # of neighbors = 372156
Ave neighs/atom = 46.5195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.24114252559, Press = -0.717333736951136
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36471.162     -36471.162     -36753.526     -36753.526      273.09139      273.09139      160496.7       160496.7      -220.95926     -220.95926    
     24000  -36464.136     -36464.136     -36754.027     -36754.027      280.37179      280.37179      160437.98      160437.98      213.7946       213.7946     
Loop time of 166.782 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.518 ns/day, 46.328 hours/ns, 5.996 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 164.7      | 164.7      | 164.7      |   0.0 | 98.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23498    | 0.23498    | 0.23498    |   0.0 |  0.14
Output  | 0.00024438 | 0.00024438 | 0.00024438 |   0.0 |  0.00
Modify  | 1.657      | 1.657      | 1.657      |   0.0 |  0.99
Other   |            | 0.1844     |            |       |  0.11

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

Total # of neighbors = 372344
Ave neighs/atom = 46.543
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.226444397419, Press = -0.799025395360884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36464.136     -36464.136     -36754.027     -36754.027      280.37179      280.37179      160437.98      160437.98      213.7946       213.7946     
     25000  -36472.004     -36472.004     -36755.345     -36755.345      274.03641      274.03641      160502         160502        -223.29722     -223.29722    
Loop time of 167.553 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.516 ns/day, 46.542 hours/ns, 5.968 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165.49     | 165.49     | 165.49     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23412    | 0.23412    | 0.23412    |   0.0 |  0.14
Output  | 0.00024376 | 0.00024376 | 0.00024376 |   0.0 |  0.00
Modify  | 1.6485     | 1.6485     | 1.6485     |   0.0 |  0.98
Other   |            | 0.1847     |            |       |  0.11

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

Total # of neighbors = 372148
Ave neighs/atom = 46.5185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.260379618664, Press = -0.752546793898843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36472.004     -36472.004     -36755.345     -36755.345      274.03641      274.03641      160502         160502        -223.29722     -223.29722    
     26000  -36468.853     -36468.853     -36752.072     -36752.072      273.91863      273.91863      160512.75      160512.75     -340.69718     -340.69718    
Loop time of 164.452 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.525 ns/day, 45.681 hours/ns, 6.081 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 162.41     | 162.41     | 162.41     |   0.0 | 98.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23306    | 0.23306    | 0.23306    |   0.0 |  0.14
Output  | 0.00026312 | 0.00026312 | 0.00026312 |   0.0 |  0.00
Modify  | 1.6254     | 1.6254     | 1.6254     |   0.0 |  0.99
Other   |            | 0.1832     |            |       |  0.11

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

Total # of neighbors = 372110
Ave neighs/atom = 46.51375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.247446717758, Press = -1.55829953004814
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36468.853     -36468.853     -36752.072     -36752.072      273.91863      273.91863      160512.75      160512.75     -340.69718     -340.69718    
     27000  -36475.522     -36475.522     -36750.956     -36750.956      266.38897      266.38897      160312.49      160312.49      837.28417      837.28417    
Loop time of 167.261 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.517 ns/day, 46.461 hours/ns, 5.979 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165.19     | 165.19     | 165.19     |   0.0 | 98.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23338    | 0.23338    | 0.23338    |   0.0 |  0.14
Output  | 0.00033379 | 0.00033379 | 0.00033379 |   0.0 |  0.00
Modify  | 1.6514     | 1.6514     | 1.6514     |   0.0 |  0.99
Other   |            | 0.1844     |            |       |  0.11

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

Total # of neighbors = 372578
Ave neighs/atom = 46.57225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.186022359776, Press = -0.76671317242318
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -36475.522     -36475.522     -36750.956     -36750.956      266.38897      266.38897      160312.49      160312.49      837.28417      837.28417    
     28000  -36472.431     -36472.431     -36754.238     -36754.238      272.5535       272.5535       160442.94      160442.94      37.368708      37.368708    
Loop time of 167.295 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.516 ns/day, 46.471 hours/ns, 5.977 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165.23     | 165.23     | 165.23     |   0.0 | 98.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23449    | 0.23449    | 0.23449    |   0.0 |  0.14
Output  | 0.00032657 | 0.00032657 | 0.00032657 |   0.0 |  0.00
Modify  | 1.6487     | 1.6487     | 1.6487     |   0.0 |  0.99
Other   |            | 0.1856     |            |       |  0.11

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0