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

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_AlmyrasSangiovanniSarakinos_2019_NAlTi__MO_958395190627_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66282.5901451204 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_958395190627_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13255.791     -13255.791     -13428         -13428          333.15         333.15         66282.59       66282.59       2775.086       2775.086     
      1000  -13064.763     -13064.763     -13233.332     -13233.332      326.10862      326.10862      67909.792      67909.792     -38.377844     -38.377844    
Loop time of 46.4135 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.862 ns/day, 12.893 hours/ns, 21.545 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 46.257     | 46.257     | 46.257     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022527   | 0.022527   | 0.022527   |   0.0 |  0.05
Output  | 0.00017904 | 0.00017904 | 0.00017904 |   0.0 |  0.00
Modify  | 0.12214    | 0.12214    | 0.12214    |   0.0 |  0.26
Other   |            | 0.01172    |            |       |  0.03

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

Total # of neighbors = 344000
Ave neighs/atom = 86
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13064.763     -13064.763     -13233.332     -13233.332      326.10862      326.10862      67909.792      67909.792     -38.377844     -38.377844    
      2000  -13082.34      -13082.34      -13250.733     -13250.733      325.76648      325.76648      67752.52       67752.52       204.84013      204.84013    
Loop time of 49.2734 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.753 ns/day, 13.687 hours/ns, 20.295 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.089     | 49.089     | 49.089     |   0.0 | 99.63
Neigh   | 0.023568   | 0.023568   | 0.023568   |   0.0 |  0.05
Comm    | 0.024127   | 0.024127   | 0.024127   |   0.0 |  0.05
Output  | 7.4379e-05 | 7.4379e-05 | 7.4379e-05 |   0.0 |  0.00
Modify  | 0.12246    | 0.12246    | 0.12246    |   0.0 |  0.25
Other   |            | 0.01424    |            |       |  0.03

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

Total # of neighbors = 330896
Ave neighs/atom = 82.724
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13082.34      -13082.34      -13250.733     -13250.733      325.76648      325.76648      67752.52       67752.52       204.84013      204.84013    
      3000  -13073.694     -13073.694     -13248.736     -13248.736      338.62924      338.62924      67780.908      67780.908      180.24421      180.24421    
Loop time of 48.5012 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.781 ns/day, 13.473 hours/ns, 20.618 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    | 48.346     | 48.346     | 48.346     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022693   | 0.022693   | 0.022693   |   0.0 |  0.05
Output  | 5.4412e-05 | 5.4412e-05 | 5.4412e-05 |   0.0 |  0.00
Modify  | 0.11956    | 0.11956    | 0.11956    |   0.0 |  0.25
Other   |            | 0.01319    |            |       |  0.03

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

Total # of neighbors = 330938
Ave neighs/atom = 82.7345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13073.694     -13073.694     -13248.736     -13248.736      338.62924      338.62924      67780.908      67780.908      180.24421      180.24421    
      4000  -13076.785     -13076.785     -13250.607     -13250.607      336.27012      336.27012      67802.786      67802.786     -247.19059     -247.19059    
Loop time of 48.7603 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.772 ns/day, 13.545 hours/ns, 20.508 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.605     | 48.605     | 48.605     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022649   | 0.022649   | 0.022649   |   0.0 |  0.05
Output  | 8.5701e-05 | 8.5701e-05 | 8.5701e-05 |   0.0 |  0.00
Modify  | 0.1205     | 0.1205     | 0.1205     |   0.0 |  0.25
Other   |            | 0.01238    |            |       |  0.03

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

Total # of neighbors = 330972
Ave neighs/atom = 82.743
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13076.785     -13076.785     -13250.607     -13250.607      336.27012      336.27012      67802.786      67802.786     -247.19059     -247.19059    
      5000  -13077.979     -13077.979     -13248.78      -13248.78       330.42621      330.42621      67811.263      67811.263     -170.47388     -170.47388    
Loop time of 48.8464 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.769 ns/day, 13.568 hours/ns, 20.472 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.681     | 48.681     | 48.681     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.032263   | 0.032263   | 0.032263   |   0.0 |  0.07
Output  | 3.8683e-05 | 3.8683e-05 | 3.8683e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.25
Other   |            | 0.01184    |            |       |  0.02

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

Total # of neighbors = 330878
Ave neighs/atom = 82.7195
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 = 334.012435988567, Press = 108.968661245656
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13077.979     -13077.979     -13248.78      -13248.78       330.42621      330.42621      67811.263      67811.263     -170.47388     -170.47388    
      6000  -13075.004     -13075.004     -13248.599     -13248.599      335.83174      335.83174      67797.046      67797.046     -11.831199     -11.831199    
Loop time of 49.2232 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.755 ns/day, 13.673 hours/ns, 20.316 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    | 49.052     | 49.052     | 49.052     |   0.0 | 99.65
Neigh   | 0.011837   | 0.011837   | 0.011837   |   0.0 |  0.02
Comm    | 0.022474   | 0.022474   | 0.022474   |   0.0 |  0.05
Output  | 4.243e-05  | 4.243e-05  | 4.243e-05  |   0.0 |  0.00
Modify  | 0.12499    | 0.12499    | 0.12499    |   0.0 |  0.25
Other   |            | 0.012      |            |       |  0.02

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

Total # of neighbors = 331022
Ave neighs/atom = 82.7555
Neighbor list builds = 1
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 = 332.322686533227, Press = -9.5874187000446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13075.004     -13075.004     -13248.599     -13248.599      335.83174      335.83174      67797.046      67797.046     -11.831199     -11.831199    
      7000  -13078.283     -13078.283     -13250.141     -13250.141      332.47034      332.47034      67809.838      67809.838     -329.12037     -329.12037    
Loop time of 48.6601 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.776 ns/day, 13.517 hours/ns, 20.551 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.496     | 48.496     | 48.496     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021888   | 0.021888   | 0.021888   |   0.0 |  0.04
Output  | 7.2165e-05 | 7.2165e-05 | 7.2165e-05 |   0.0 |  0.00
Modify  | 0.12837    | 0.12837    | 0.12837    |   0.0 |  0.26
Other   |            | 0.01345    |            |       |  0.03

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

Total # of neighbors = 330770
Ave neighs/atom = 82.6925
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.195668138065, Press = 23.8798167502248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13078.283     -13078.283     -13250.141     -13250.141      332.47034      332.47034      67809.838      67809.838     -329.12037     -329.12037    
      8000  -13077.049     -13077.049     -13247.789     -13247.789      330.3093       330.3093       67740.969      67740.969      613.24692      613.24692    
Loop time of 48.6503 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.776 ns/day, 13.514 hours/ns, 20.555 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.489     | 48.489     | 48.489     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021972   | 0.021972   | 0.021972   |   0.0 |  0.05
Output  | 7.3267e-05 | 7.3267e-05 | 7.3267e-05 |   0.0 |  0.00
Modify  | 0.12672    | 0.12672    | 0.12672    |   0.0 |  0.26
Other   |            | 0.01266    |            |       |  0.03

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

Total # of neighbors = 330820
Ave neighs/atom = 82.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 = 332.702791628249, Press = -13.5379281418113
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13077.049     -13077.049     -13247.789     -13247.789      330.3093       330.3093       67740.969      67740.969      613.24692      613.24692    
      9000  -13069.064     -13069.064     -13246.941     -13246.941      344.11641      344.11641      67879.192      67879.192     -710.02693     -710.02693    
Loop time of 48.5104 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.781 ns/day, 13.475 hours/ns, 20.614 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.355     | 48.355     | 48.355     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021564   | 0.021564   | 0.021564   |   0.0 |  0.04
Output  | 5.9331e-05 | 5.9331e-05 | 5.9331e-05 |   0.0 |  0.00
Modify  | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.25
Other   |            | 0.01079    |            |       |  0.02

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

Total # of neighbors = 331060
Ave neighs/atom = 82.765
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.294916342637, Press = 7.16053010061688
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13069.064     -13069.064     -13246.941     -13246.941      344.11641      344.11641      67879.192      67879.192     -710.02693     -710.02693    
     10000  -13079.953     -13079.953     -13249.185     -13249.185      327.38971      327.38971      67742.106      67742.106      493.57951      493.57951    
Loop time of 48.9607 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.765 ns/day, 13.600 hours/ns, 20.425 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.804     | 48.804     | 48.804     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021947   | 0.021947   | 0.021947   |   0.0 |  0.04
Output  | 4.0987e-05 | 4.0987e-05 | 4.0987e-05 |   0.0 |  0.00
Modify  | 0.12389    | 0.12389    | 0.12389    |   0.0 |  0.25
Other   |            | 0.01097    |            |       |  0.02

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

Total # of neighbors = 330520
Ave neighs/atom = 82.63
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.442110774842, Press = 2.32407804583308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13079.953     -13079.953     -13249.185     -13249.185      327.38971      327.38971      67742.106      67742.106      493.57951      493.57951    
     11000  -13080.547     -13080.547     -13249.679     -13249.679      327.19688      327.19688      67826.366      67826.366     -485.47013     -485.47013    
Loop time of 48.7628 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.772 ns/day, 13.545 hours/ns, 20.507 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.608     | 48.608     | 48.608     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021693   | 0.021693   | 0.021693   |   0.0 |  0.04
Output  | 2.9916e-05 | 2.9916e-05 | 2.9916e-05 |   0.0 |  0.00
Modify  | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.25
Other   |            | 0.01077    |            |       |  0.02

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

Total # of neighbors = 331022
Ave neighs/atom = 82.7555
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.390066930944, Press = 1.3155469484702
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13080.547     -13080.547     -13249.679     -13249.679      327.19688      327.19688      67826.366      67826.366     -485.47013     -485.47013    
     12000  -13077.506     -13077.506     -13247.403     -13247.403      328.67639      328.67639      67683.138      67683.138      1293.6461      1293.6461    
Loop time of 48.5685 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.779 ns/day, 13.491 hours/ns, 20.589 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.414     | 48.414     | 48.414     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021695   | 0.021695   | 0.021695   |   0.0 |  0.04
Output  | 5.9221e-05 | 5.9221e-05 | 5.9221e-05 |   0.0 |  0.00
Modify  | 0.12249    | 0.12249    | 0.12249    |   0.0 |  0.25
Other   |            | 0.01065    |            |       |  0.02

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

Total # of neighbors = 330762
Ave neighs/atom = 82.6905
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.015455865443, Press = 1.71931691720159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13077.506     -13077.506     -13247.403     -13247.403      328.67639      328.67639      67683.138      67683.138      1293.6461      1293.6461    
     13000  -13073.343     -13073.343     -13246.397     -13246.397      334.78384      334.78384      67910.612      67910.612     -1117.9814     -1117.9814    
Loop time of 48.7048 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.774 ns/day, 13.529 hours/ns, 20.532 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.55      | 48.55      | 48.55      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021629   | 0.021629   | 0.021629   |   0.0 |  0.04
Output  | 4.1829e-05 | 4.1829e-05 | 4.1829e-05 |   0.0 |  0.00
Modify  | 0.1224     | 0.1224     | 0.1224     |   0.0 |  0.25
Other   |            | 0.01072    |            |       |  0.02

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

Total # of neighbors = 331186
Ave neighs/atom = 82.7965
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.153229411892, Press = -2.13199133473221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13073.343     -13073.343     -13246.397     -13246.397      334.78384      334.78384      67910.612      67910.612     -1117.9814     -1117.9814    
     14000  -13077.277     -13077.277     -13252.312     -13252.312      338.61669      338.61669      67639.331      67639.331      1420.4759      1420.4759    
Loop time of 48.6141 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.777 ns/day, 13.504 hours/ns, 20.570 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    | 48.455     | 48.455     | 48.455     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022107   | 0.022107   | 0.022107   |   0.0 |  0.05
Output  | 7.1214e-05 | 7.1214e-05 | 7.1214e-05 |   0.0 |  0.00
Modify  | 0.12468    | 0.12468    | 0.12468    |   0.0 |  0.26
Other   |            | 0.01179    |            |       |  0.02

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

Total # of neighbors = 330474
Ave neighs/atom = 82.6185
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.299864642061, Press = 2.40442928112158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13077.277     -13077.277     -13252.312     -13252.312      338.61669      338.61669      67639.331      67639.331      1420.4759      1420.4759    
     15000  -13076.059     -13076.059     -13247.177     -13247.177      331.04012      331.04012      67865.714      67865.714     -644.02194     -644.02194    
Loop time of 48.6865 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.775 ns/day, 13.524 hours/ns, 20.540 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    | 48.524     | 48.524     | 48.524     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022703   | 0.022703   | 0.022703   |   0.0 |  0.05
Output  | 5.2078e-05 | 5.2078e-05 | 5.2078e-05 |   0.0 |  0.00
Modify  | 0.12653    | 0.12653    | 0.12653    |   0.0 |  0.26
Other   |            | 0.01299    |            |       |  0.03

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

Total # of neighbors = 331326
Ave neighs/atom = 82.8315
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.243097162724, Press = 1.79234672568341
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13076.059     -13076.059     -13247.177     -13247.177      331.04012      331.04012      67865.714      67865.714     -644.02194     -644.02194    
     16000  -13080.247     -13080.247     -13252.696     -13252.696      333.61489      333.61489      67721.704      67721.704      450.01668      450.01668    
Loop time of 49.1857 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.757 ns/day, 13.663 hours/ns, 20.331 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    | 49.02      | 49.02      | 49.02      |   0.0 | 99.66
Neigh   | 0.011885   | 0.011885   | 0.011885   |   0.0 |  0.02
Comm    | 0.022051   | 0.022051   | 0.022051   |   0.0 |  0.04
Output  | 2.9956e-05 | 2.9956e-05 | 2.9956e-05 |   0.0 |  0.00
Modify  | 0.12163    | 0.12163    | 0.12163    |   0.0 |  0.25
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 330922
Ave neighs/atom = 82.7305
Neighbor list builds = 1
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.398088780106, Press = -0.93266670302351
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13080.247     -13080.247     -13252.696     -13252.696      333.61489      333.61489      67721.704      67721.704      450.01668      450.01668    
     17000  -13072.522     -13072.522     -13247.112     -13247.112      337.75731      337.75731      67903.006      67903.006     -1059.9571     -1059.9571    
Loop time of 48.6891 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.775 ns/day, 13.525 hours/ns, 20.538 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    | 48.535     | 48.535     | 48.535     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021796   | 0.021796   | 0.021796   |   0.0 |  0.04
Output  | 8.9408e-05 | 8.9408e-05 | 8.9408e-05 |   0.0 |  0.00
Modify  | 0.12167    | 0.12167    | 0.12167    |   0.0 |  0.25
Other   |            | 0.01047    |            |       |  0.02

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

Total # of neighbors = 331006
Ave neighs/atom = 82.7515
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.383533081314, Press = 2.04144840380504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13072.522     -13072.522     -13247.112     -13247.112      337.75731      337.75731      67903.006      67903.006     -1059.9571     -1059.9571    
     18000  -13078.737     -13078.737     -13248.224     -13248.224      327.88404      327.88404      67706.403      67706.403      952.49634      952.49634    
Loop time of 48.6651 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.775 ns/day, 13.518 hours/ns, 20.549 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.511     | 48.511     | 48.511     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021984   | 0.021984   | 0.021984   |   0.0 |  0.05
Output  | 4.3641e-05 | 4.3641e-05 | 4.3641e-05 |   0.0 |  0.00
Modify  | 0.12186    | 0.12186    | 0.12186    |   0.0 |  0.25
Other   |            | 0.01055    |            |       |  0.02

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

Total # of neighbors = 330582
Ave neighs/atom = 82.6455
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.457910942208, Press = 0.116323722862995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13078.737     -13078.737     -13248.224     -13248.224      327.88404      327.88404      67706.403      67706.403      952.49634      952.49634    
     19000  -13069.469     -13069.469     -13245.938     -13245.938      341.3902       341.3902       67855.286      67855.286     -398.94202     -398.94202    
Loop time of 48.6335 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.777 ns/day, 13.509 hours/ns, 20.562 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    | 48.479     | 48.479     | 48.479     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022033   | 0.022033   | 0.022033   |   0.0 |  0.05
Output  | 4.1037e-05 | 4.1037e-05 | 4.1037e-05 |   0.0 |  0.00
Modify  | 0.12205    | 0.12205    | 0.12205    |   0.0 |  0.25
Other   |            | 0.01063    |            |       |  0.02

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

Total # of neighbors = 331036
Ave neighs/atom = 82.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.563921138992, Press = 0.678566772740648
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13069.469     -13069.469     -13245.938     -13245.938      341.3902       341.3902       67855.286      67855.286     -398.94202     -398.94202    
     20000  -13079.126     -13079.126     -13250.21      -13250.21       330.9738       330.9738       67773.422      67773.422      109.54229      109.54229    
Loop time of 48.6919 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.774 ns/day, 13.526 hours/ns, 20.537 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.537     | 48.537     | 48.537     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022074   | 0.022074   | 0.022074   |   0.0 |  0.05
Output  | 4.1648e-05 | 4.1648e-05 | 4.1648e-05 |   0.0 |  0.00
Modify  | 0.12234    | 0.12234    | 0.12234    |   0.0 |  0.25
Other   |            | 0.01062    |            |       |  0.02

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

Total # of neighbors = 330646
Ave neighs/atom = 82.6615
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.639326239424, Press = 0.48227661828084
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13079.126     -13079.126     -13250.21      -13250.21       330.9738       330.9738       67773.422      67773.422      109.54229      109.54229    
     21000  -13074.071     -13074.071     -13247.912     -13247.912      336.30824      336.30824      67795.248      67795.248      67.701573      67.701573    
Loop time of 48.6681 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.775 ns/day, 13.519 hours/ns, 20.547 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    | 48.513     | 48.513     | 48.513     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022263   | 0.022263   | 0.022263   |   0.0 |  0.05
Output  | 0.00010965 | 0.00010965 | 0.00010965 |   0.0 |  0.00
Modify  | 0.12247    | 0.12247    | 0.12247    |   0.0 |  0.25
Other   |            | 0.01061    |            |       |  0.02

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

Total # of neighbors = 330874
Ave neighs/atom = 82.7185
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.675647431076, Press = -0.486660959943349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13074.071     -13074.071     -13247.912     -13247.912      336.30824      336.30824      67795.248      67795.248      67.701573      67.701573    
     22000  -13075.268     -13075.268     -13249.457     -13249.457      336.98008      336.98008      67790.744      67790.744     -50.020098     -50.020098    
Loop time of 48.7664 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.772 ns/day, 13.546 hours/ns, 20.506 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    | 48.612     | 48.612     | 48.612     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022046   | 0.022046   | 0.022046   |   0.0 |  0.05
Output  | 4.0065e-05 | 4.0065e-05 | 4.0065e-05 |   0.0 |  0.00
Modify  | 0.12206    | 0.12206    | 0.12206    |   0.0 |  0.25
Other   |            | 0.01064    |            |       |  0.02

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

Total # of neighbors = 330840
Ave neighs/atom = 82.71
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.626412168809, Press = 0.800364888327245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13075.268     -13075.268     -13249.457     -13249.457      336.98008      336.98008      67790.744      67790.744     -50.020098     -50.020098    
     23000  -13081.031     -13081.031     -13249.791     -13249.791      326.4771       326.4771       67745.31       67745.31       340.92203      340.92203    
Loop time of 48.7849 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.771 ns/day, 13.551 hours/ns, 20.498 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    | 48.631     | 48.631     | 48.631     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021712   | 0.021712   | 0.021712   |   0.0 |  0.04
Output  | 4.4614e-05 | 4.4614e-05 | 4.4614e-05 |   0.0 |  0.00
Modify  | 0.12136    | 0.12136    | 0.12136    |   0.0 |  0.25
Other   |            | 0.0105     |            |       |  0.02

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

Total # of neighbors = 330954
Ave neighs/atom = 82.7385
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.638497329539, Press = -1.30246725358698
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13081.031     -13081.031     -13249.791     -13249.791      326.4771       326.4771       67745.31       67745.31       340.92203      340.92203    
     24000  -13074.545     -13074.545     -13247.321     -13247.321      334.24746      334.24746      67845.679      67845.679     -471.21984     -471.21984    
Loop time of 48.9947 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.763 ns/day, 13.610 hours/ns, 20.410 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    | 48.829     | 48.829     | 48.829     |   0.0 | 99.66
Neigh   | 0.011869   | 0.011869   | 0.011869   |   0.0 |  0.02
Comm    | 0.021935   | 0.021935   | 0.021935   |   0.0 |  0.04
Output  | 3.732e-05  | 3.732e-05  | 3.732e-05  |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.25
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 330718
Ave neighs/atom = 82.6795
Neighbor list builds = 1
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.582050989828, Press = 2.10878652422433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13074.545     -13074.545     -13247.321     -13247.321      334.24746      334.24746      67845.679      67845.679     -471.21984     -471.21984    
     25000  -13077.42      -13077.42      -13247.488     -13247.488      329.00928      329.00928      67750.25       67750.25       568.24844      568.24844    
Loop time of 48.6515 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.776 ns/day, 13.514 hours/ns, 20.554 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    | 48.498     | 48.498     | 48.498     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021602   | 0.021602   | 0.021602   |   0.0 |  0.04
Output  | 6.9441e-05 | 6.9441e-05 | 6.9441e-05 |   0.0 |  0.00
Modify  | 0.12103    | 0.12103    | 0.12103    |   0.0 |  0.25
Other   |            | 0.01045    |            |       |  0.02

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

Total # of neighbors = 330834
Ave neighs/atom = 82.7085
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.596091623247, Press = -1.73771166181003
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13077.42      -13077.42      -13247.488     -13247.488      329.00928      329.00928      67750.25       67750.25       568.24844      568.24844    
     26000  -13072.085     -13072.085     -13244.791     -13244.791      334.11204      334.11204      67872.825      67872.825     -604.76795     -604.76795    
Loop time of 48.5818 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.778 ns/day, 13.495 hours/ns, 20.584 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    | 48.429     | 48.429     | 48.429     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021713   | 0.021713   | 0.021713   |   0.0 |  0.04
Output  | 3.6869e-05 | 3.6869e-05 | 3.6869e-05 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.25
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 330904
Ave neighs/atom = 82.726
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.579827739616, Press = 1.78355367371876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13072.085     -13072.085     -13244.791     -13244.791      334.11204      334.11204      67872.825      67872.825     -604.76795     -604.76795    
     27000  -13077.864     -13077.864     -13252.344     -13252.344      337.54429      337.54429      67755.38       67755.38       139.04742      139.04742    
Loop time of 48.6957 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.774 ns/day, 13.527 hours/ns, 20.536 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    | 48.543     | 48.543     | 48.543     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021675   | 0.021675   | 0.021675   |   0.0 |  0.04
Output  | 3.0377e-05 | 3.0377e-05 | 3.0377e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  0.25
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 330702
Ave neighs/atom = 82.6755
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.561426297766, Press = -0.680588923772419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13077.864     -13077.864     -13252.344     -13252.344      337.54429      337.54429      67755.38       67755.38       139.04742      139.04742    
     28000  -13076.095     -13076.095     -13249.58      -13249.58       335.61855      335.61855      67791.364      67791.364     -79.576342     -79.576342    
Loop time of 48.6741 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.775 ns/day, 13.521 hours/ns, 20.545 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    | 48.521     | 48.521     | 48.521     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021682   | 0.021682   | 0.021682   |   0.0 |  0.04
Output  | 3.778e-05  | 3.778e-05  | 3.778e-05  |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.25
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 331040
Ave neighs/atom = 82.76
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.541814225289, Press = 0.978573848483388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13076.095     -13076.095     -13249.58      -13249.58       335.61855      335.61855      67791.364      67791.364     -79.576342     -79.576342    
     29000  -13077.972     -13077.972     -13248.052     -13248.052      329.03225      329.03225      67779.006      67779.006      207.40492      207.40492    
Loop time of 48.6964 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.774 ns/day, 13.527 hours/ns, 20.535 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    | 48.543     | 48.543     | 48.543     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02162    | 0.02162    | 0.02162    |   0.0 |  0.04
Output  | 3.764e-05  | 3.764e-05  | 3.764e-05  |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.25
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 330834
Ave neighs/atom = 82.7085
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.466584206407, Press = -0.483885613749083
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13077.972     -13077.972     -13248.052     -13248.052      329.03225      329.03225      67779.006      67779.006      207.40492      207.40492    
     30000  -13079.003     -13079.003     -13248.096     -13248.096      327.12287      327.12287      67826.086      67826.086     -358.48638     -358.48638    
Loop time of 48.7268 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.773 ns/day, 13.535 hours/ns, 20.523 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    | 48.573     | 48.573     | 48.573     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021637   | 0.021637   | 0.021637   |   0.0 |  0.04
Output  | 3.7781e-05 | 3.7781e-05 | 3.7781e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.25
Other   |            | 0.01038    |            |       |  0.02

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

Total # of neighbors = 330938
Ave neighs/atom = 82.7345
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.365676391287, Press = 0.988028098873701
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13079.003     -13079.003     -13248.096     -13248.096      327.12287      327.12287      67826.086      67826.086     -358.48638     -358.48638    
     31000  -13076.838     -13076.838     -13250.002     -13250.002      334.99661      334.99661      67780.569      67780.569      41.035456      41.035456    
Loop time of 48.5904 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.778 ns/day, 13.497 hours/ns, 20.580 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    | 48.437     | 48.437     | 48.437     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021596   | 0.021596   | 0.021596   |   0.0 |  0.04
Output  | 3.9324e-05 | 3.9324e-05 | 3.9324e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  0.25
Other   |            | 0.01038    |            |       |  0.02

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

Total # of neighbors = 330738
Ave neighs/atom = 82.6845
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.336087921824, Press = -1.77839262266271
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13076.838     -13076.838     -13250.002     -13250.002      334.99661      334.99661      67780.569      67780.569      41.035456      41.035456    
     32000  -13077.002     -13077.002     -13249.599     -13249.599      333.90034      333.90034      67783.426      67783.426      10.901994      10.901994    
Loop time of 48.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.773 ns/day, 13.535 hours/ns, 20.523 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    | 48.573     | 48.573     | 48.573     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02172    | 0.02172    | 0.02172    |   0.0 |  0.04
Output  | 3.158e-05  | 3.158e-05  | 3.158e-05  |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.25
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 330886
Ave neighs/atom = 82.7215
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.27919764338, Press = 2.10010468332908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13077.002     -13077.002     -13249.599     -13249.599      333.90034      333.90034      67783.426      67783.426      10.901994      10.901994    
     33000  -13079.794     -13079.794     -13248.682     -13248.682      326.72453      326.72453      67815.098      67815.098     -258.19497     -258.19497    
Loop time of 48.6604 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.776 ns/day, 13.517 hours/ns, 20.551 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    | 48.507     | 48.507     | 48.507     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021669   | 0.021669   | 0.021669   |   0.0 |  0.04
Output  | 4.0606e-05 | 4.0606e-05 | 4.0606e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.25
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 330810
Ave neighs/atom = 82.7025
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.187250060971, Press = -0.330438279613992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13079.794     -13079.794     -13248.682     -13248.682      326.72453      326.72453      67815.098      67815.098     -258.19497     -258.19497    
     34000  -13077.794     -13077.794     -13248.396     -13248.396      330.04181      330.04181      67788.315      67788.315      63.490422      63.490422    
Loop time of 48.6492 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.776 ns/day, 13.514 hours/ns, 20.555 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 48.496     | 48.496     | 48.496     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021606   | 0.021606   | 0.021606   |   0.0 |  0.04
Output  | 3.0939e-05 | 3.0939e-05 | 3.0939e-05 |   0.0 |  0.00
Modify  | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.25
Other   |            | 0.01038    |            |       |  0.02

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

Total # of neighbors = 330650
Ave neighs/atom = 82.6625
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.187961232972, Press = 0.547140177408774
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13077.794     -13077.794     -13248.396     -13248.396      330.04181      330.04181      67788.315      67788.315      63.490422      63.490422    
     35000  -13079.011     -13079.011     -13251.136     -13251.136      332.988        332.988        67758.922      67758.922      153.32946      153.32946    
Loop time of 48.6848 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.775 ns/day, 13.524 hours/ns, 20.540 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    | 48.532     | 48.532     | 48.532     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021588   | 0.021588   | 0.021588   |   0.0 |  0.04
Output  | 3.8382e-05 | 3.8382e-05 | 3.8382e-05 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.25
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 330878
Ave neighs/atom = 82.7195
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.209541240771, Press = -0.223083159655454
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13079.011     -13079.011     -13251.136     -13251.136      332.988        332.988        67758.922      67758.922      153.32946      153.32946    
     36000  -13080.9       -13080.9       -13250.629     -13250.629      328.35204      328.35204      67795.828      67795.828     -199.66522     -199.66522    
Loop time of 48.6094 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.777 ns/day, 13.503 hours/ns, 20.572 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    | 48.456     | 48.456     | 48.456     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021618   | 0.021618   | 0.021618   |   0.0 |  0.04
Output  | 3.7831e-05 | 3.7831e-05 | 3.7831e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.25
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 331030
Ave neighs/atom = 82.7575
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.208803680961, Press = 0.515637748770125
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13080.9       -13080.9       -13250.629     -13250.629      328.35204      328.35204      67795.828      67795.828     -199.66522     -199.66522    
     37000  -13075.718     -13075.718     -13248.326     -13248.326      333.92077      333.92077      67791.152      67791.152      101.98589      101.98589    
Loop time of 48.5936 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.778 ns/day, 13.498 hours/ns, 20.579 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    | 48.44      | 48.44      | 48.44      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021538   | 0.021538   | 0.021538   |   0.0 |  0.04
Output  | 4.2109e-05 | 4.2109e-05 | 4.2109e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.25
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 330704
Ave neighs/atom = 82.676
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.206914522432, Press = -0.423383837078422
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13075.718     -13075.718     -13248.326     -13248.326      333.92077      333.92077      67791.152      67791.152      101.98589      101.98589    
     38000  -13080.967     -13080.967     -13252.964     -13252.964      332.74087      332.74087      67772.738      67772.738     -141.40993     -141.40993    
Loop time of 48.4715 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.782 ns/day, 13.464 hours/ns, 20.631 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    | 48.318     | 48.318     | 48.318     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021683   | 0.021683   | 0.021683   |   0.0 |  0.04
Output  | 2.8694e-05 | 2.8694e-05 | 2.8694e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.25
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 330760
Ave neighs/atom = 82.69
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
67791.869679176

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0