# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 5.430545687675476*${_u_distance}
variable latticeconst_converted equal 5.430545687675476*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.43054568767548
Lattice spacing in x,y,z = 5.4305457 5.4305457 5.4305457
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (54.305457 54.305457 54.305457)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0 0 0) to (54.305457 54.305457 54.305457)
  create_atoms CPU = 0.010 seconds

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

kim_interactions Si

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

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


mass          1 ${mass_converted}
mass          1 28.0855

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

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

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

variable temp_converted equal 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_533426548156_002#item-citation

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

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

Performance: 0.237 ns/day, 101.364 hours/ns, 2.740 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 363.21     | 363.21     | 363.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20647    | 0.20647    | 0.20647    |   0.0 |  0.06
Output  | 0.00028481 | 0.00028481 | 0.00028481 |   0.0 |  0.00
Modify  | 1.3313     | 1.3313     | 1.3313     |   0.0 |  0.36
Other   |            | 0.1636     |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.66     | 369.66     | 369.66     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20756    | 0.20756    | 0.20756    |   0.0 |  0.06
Output  | 0.00027582 | 0.00027582 | 0.00027582 |   0.0 |  0.00
Modify  | 1.3416     | 1.3416     | 1.3416     |   0.0 |  0.36
Other   |            | 0.1647     |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.37     | 368.37     | 368.37     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20569    | 0.20569    | 0.20569    |   0.0 |  0.06
Output  | 0.00031824 | 0.00031824 | 0.00031824 |   0.0 |  0.00
Modify  | 1.3322     | 1.3322     | 1.3322     |   0.0 |  0.36
Other   |            | 0.1647     |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 366.9      | 366.9      | 366.9      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2019     | 0.2019     | 0.2019     |   0.0 |  0.05
Output  | 0.00027175 | 0.00027175 | 0.00027175 |   0.0 |  0.00
Modify  | 1.3269     | 1.3269     | 1.3269     |   0.0 |  0.36
Other   |            | 0.1641     |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 367.91     | 367.91     | 367.91     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20396    | 0.20396    | 0.20396    |   0.0 |  0.06
Output  | 0.00023509 | 0.00023509 | 0.00023509 |   0.0 |  0.00
Modify  | 1.334      | 1.334      | 1.334      |   0.0 |  0.36
Other   |            | 0.1653     |            |       |  0.04

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

Total # of neighbors = 385226
Ave neighs/atom = 48.15325
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 = 297.52058225987, Press = -13.0065913370084
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -36220.582     -36220.582     -36527.048     -36527.048      296.40219      296.40219      158783.45      158783.45     -237.04688     -237.04688    
      6000  -36233.943     -36233.943     -36536.481     -36536.481      292.60395      292.60395      158742.37      158742.37     -13.116668     -13.116668    
Loop time of 371.355 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.62     | 369.62     | 369.62     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2039     | 0.2039     | 0.2039     |   0.0 |  0.05
Output  | 0.00028212 | 0.00028212 | 0.00028212 |   0.0 |  0.00
Modify  | 1.37       | 1.37       | 1.37       |   0.0 |  0.37
Other   |            | 0.1651     |            |       |  0.04

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

Total # of neighbors = 385092
Ave neighs/atom = 48.1365
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 = 293.176359620964, Press = -1.53079260786251
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -36233.943     -36233.943     -36536.481     -36536.481      292.60395      292.60395      158742.37      158742.37     -13.116668     -13.116668    
      7000  -36223.756     -36223.756     -36526.053     -36526.053      292.37016      292.37016      158553.38      158553.38      564.34         564.34       
Loop time of 370.739 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.99     | 368.99     | 368.99     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20572    | 0.20572    | 0.20572    |   0.0 |  0.06
Output  | 0.00028763 | 0.00028763 | 0.00028763 |   0.0 |  0.00
Modify  | 1.3746     | 1.3746     | 1.3746     |   0.0 |  0.37
Other   |            | 0.1652     |            |       |  0.04

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

Total # of neighbors = 384994
Ave neighs/atom = 48.12425
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 = 293.354162509425, Press = -4.52989977902486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -36223.756     -36223.756     -36526.053     -36526.053      292.37016      292.37016      158553.38      158553.38      564.34         564.34       
      8000  -36230.867     -36230.867     -36532.491     -36532.491      291.71987      291.71987      158830.71      158830.71     -904.97869     -904.97869    
Loop time of 371.349 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.59     | 369.59     | 369.59     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20546    | 0.20546    | 0.20546    |   0.0 |  0.06
Output  | 0.00023774 | 0.00023774 | 0.00023774 |   0.0 |  0.00
Modify  | 1.3843     | 1.3843     | 1.3843     |   0.0 |  0.37
Other   |            | 0.1656     |            |       |  0.04

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

Total # of neighbors = 386604
Ave neighs/atom = 48.3255
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 = 293.166560253598, Press = -2.50033822800301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -36230.867     -36230.867     -36532.491     -36532.491      291.71987      291.71987      158830.71      158830.71     -904.97869     -904.97869    
      9000  -36226.269     -36226.269     -36529.643     -36529.643      293.41198      293.41198      158734.23      158734.23     -325.68781     -325.68781    
Loop time of 368.711 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 366.98     | 366.98     | 366.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20384    | 0.20384    | 0.20384    |   0.0 |  0.06
Output  | 0.00023369 | 0.00023369 | 0.00023369 |   0.0 |  0.00
Modify  | 1.3623     | 1.3623     | 1.3623     |   0.0 |  0.37
Other   |            | 0.1636     |            |       |  0.04

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

Total # of neighbors = 385290
Ave neighs/atom = 48.16125
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 = 293.282894840153, Press = -4.94416551451987
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -36226.269     -36226.269     -36529.643     -36529.643      293.41198      293.41198      158734.23      158734.23     -325.68781     -325.68781    
     10000  -36229.112     -36229.112     -36531.183     -36531.183      292.15181      292.15181      158627.39      158627.39      202.92379      202.92379    
Loop time of 369.337 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 367.61     | 367.61     | 367.61     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20393    | 0.20393    | 0.20393    |   0.0 |  0.06
Output  | 0.0002357  | 0.0002357  | 0.0002357  |   0.0 |  0.00
Modify  | 1.3629     | 1.3629     | 1.3629     |   0.0 |  0.37
Other   |            | 0.1638     |            |       |  0.04

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

Total # of neighbors = 385834
Ave neighs/atom = 48.22925
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 = 293.158015155527, Press = -1.81140440527753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -36229.112     -36229.112     -36531.183     -36531.183      292.15181      292.15181      158627.39      158627.39      202.92379      202.92379    
     11000  -36227.173     -36227.173     -36529.172     -36529.172      292.08234      292.08234      158666.17      158666.17     -32.984662     -32.984662    
Loop time of 370.515 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.78     | 368.78     | 368.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20279    | 0.20279    | 0.20279    |   0.0 |  0.05
Output  | 0.000275   | 0.000275   | 0.000275   |   0.0 |  0.00
Modify  | 1.3661     | 1.3661     | 1.3661     |   0.0 |  0.37
Other   |            | 0.1649     |            |       |  0.04

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

Total # of neighbors = 386050
Ave neighs/atom = 48.25625
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 = 293.264285992526, Press = 0.853835636737374
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -36227.173     -36227.173     -36529.172     -36529.172      292.08234      292.08234      158666.17      158666.17     -32.984662     -32.984662    
     12000  -36230.694     -36230.694     -36537.773     -36537.773      296.99457      296.99457      158774.75      158774.75     -353.09101     -353.09101    
Loop time of 370.367 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.62     | 368.62     | 368.62     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20425    | 0.20425    | 0.20425    |   0.0 |  0.06
Output  | 0.00022975 | 0.00022975 | 0.00022975 |   0.0 |  0.00
Modify  | 1.373      | 1.373      | 1.373      |   0.0 |  0.37
Other   |            | 0.1648     |            |       |  0.04

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

Total # of neighbors = 386112
Ave neighs/atom = 48.264
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 = 293.225104478376, Press = 1.65979977196995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -36230.694     -36230.694     -36537.773     -36537.773      296.99457      296.99457      158774.75      158774.75     -353.09101     -353.09101    
     13000  -36223.857     -36223.857     -36526.867     -36526.867      293.05976      293.05976      158749.58      158749.58     -395.41922     -395.41922    
Loop time of 371.78 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.03     | 370.03     | 370.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20453    | 0.20453    | 0.20453    |   0.0 |  0.06
Output  | 0.00023087 | 0.00023087 | 0.00023087 |   0.0 |  0.00
Modify  | 1.3772     | 1.3772     | 1.3772     |   0.0 |  0.37
Other   |            | 0.1642     |            |       |  0.04

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

Total # of neighbors = 384984
Ave neighs/atom = 48.123
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 = 293.228879704274, Press = -0.233754574452856
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -36223.857     -36223.857     -36526.867     -36526.867      293.05976      293.05976      158749.58      158749.58     -395.41922     -395.41922    
     14000  -36239.542     -36239.542     -36537.599     -36537.599      288.27012      288.27012      158720.78      158720.78     -105.98902     -105.98902    
Loop time of 372.264 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.52     | 370.52     | 370.52     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20427    | 0.20427    | 0.20427    |   0.0 |  0.05
Output  | 0.00023022 | 0.00023022 | 0.00023022 |   0.0 |  0.00
Modify  | 1.376      | 1.376      | 1.376      |   0.0 |  0.37
Other   |            | 0.1651     |            |       |  0.04

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

Total # of neighbors = 386032
Ave neighs/atom = 48.254
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 = 293.103244819083, Press = -2.42295008399931
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -36239.542     -36239.542     -36537.599     -36537.599      288.27012      288.27012      158720.78      158720.78     -105.98902     -105.98902    
     15000  -36226.683     -36226.683     -36532.891     -36532.891      296.15253      296.15253      158666.02      158666.02      111.06455      111.06455    
Loop time of 371.2 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.45     | 369.45     | 369.45     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20403    | 0.20403    | 0.20403    |   0.0 |  0.05
Output  | 0.00023641 | 0.00023641 | 0.00023641 |   0.0 |  0.00
Modify  | 1.3751     | 1.3751     | 1.3751     |   0.0 |  0.37
Other   |            | 0.166      |            |       |  0.04

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

Total # of neighbors = 385326
Ave neighs/atom = 48.16575
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 = 293.02781404771, Press = -1.52198418748662
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -36226.683     -36226.683     -36532.891     -36532.891      296.15253      296.15253      158666.02      158666.02      111.06455      111.06455    
     16000  -36235.988     -36235.988     -36531.876     -36531.876      286.17163      286.17163      158611.66      158611.66      276.20504      276.20504    
Loop time of 370.726 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.98     | 368.98     | 368.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20216    | 0.20216    | 0.20216    |   0.0 |  0.05
Output  | 0.00023708 | 0.00023708 | 0.00023708 |   0.0 |  0.00
Modify  | 1.3749     | 1.3749     | 1.3749     |   0.0 |  0.37
Other   |            | 0.1661     |            |       |  0.04

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

Total # of neighbors = 385772
Ave neighs/atom = 48.2215
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 = 292.984762410602, Press = 0.642867965835584
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -36235.988     -36235.988     -36531.876     -36531.876      286.17163      286.17163      158611.66      158611.66      276.20504      276.20504    
     17000  -36228.188     -36228.188     -36532.681     -36532.681      294.49417      294.49417      158806.67      158806.67     -627.45871     -627.45871    
Loop time of 371.052 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.31     | 369.31     | 369.31     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20362    | 0.20362    | 0.20362    |   0.0 |  0.05
Output  | 0.00028316 | 0.00028316 | 0.00028316 |   0.0 |  0.00
Modify  | 1.3769     | 1.3769     | 1.3769     |   0.0 |  0.37
Other   |            | 0.1649     |            |       |  0.04

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

Total # of neighbors = 386118
Ave neighs/atom = 48.26475
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 = 292.870142444006, Press = 0.166610849274802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -36228.188     -36228.188     -36532.681     -36532.681      294.49417      294.49417      158806.67      158806.67     -627.45871     -627.45871    
     18000  -36233.674     -36233.674     -36535.875     -36535.875      292.27791      292.27791      158715.03      158715.03     -24.025114     -24.025114    
Loop time of 370.778 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.03     | 369.03     | 369.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20446    | 0.20446    | 0.20446    |   0.0 |  0.06
Output  | 0.00023881 | 0.00023881 | 0.00023881 |   0.0 |  0.00
Modify  | 1.3741     | 1.3741     | 1.3741     |   0.0 |  0.37
Other   |            | 0.1659     |            |       |  0.04

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

Total # of neighbors = 385410
Ave neighs/atom = 48.17625
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 = 292.873937793556, Press = -0.153111564805827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -36233.674     -36233.674     -36535.875     -36535.875      292.27791      292.27791      158715.03      158715.03     -24.025114     -24.025114    
     19000  -36227.544     -36227.544     -36531.697     -36531.697      294.16503      294.16503      158629.19      158629.19      476.71549      476.71549    
Loop time of 371.724 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.98     | 369.98     | 369.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20497    | 0.20497    | 0.20497    |   0.0 |  0.06
Output  | 0.00029471 | 0.00029471 | 0.00029471 |   0.0 |  0.00
Modify  | 1.3778     | 1.3778     | 1.3778     |   0.0 |  0.37
Other   |            | 0.1651     |            |       |  0.04

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

Total # of neighbors = 385348
Ave neighs/atom = 48.1685
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 = 292.869505668533, Press = -0.817260635095212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -36227.544     -36227.544     -36531.697     -36531.697      294.16503      294.16503      158629.19      158629.19      476.71549      476.71549    
     20000  -36232.772     -36232.772     -36533.093     -36533.093      290.4597       290.4597       158730.55      158730.55     -101.0028      -101.0028     
Loop time of 370.551 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.81     | 368.81     | 368.81     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20426    | 0.20426    | 0.20426    |   0.0 |  0.06
Output  | 0.00023294 | 0.00023294 | 0.00023294 |   0.0 |  0.00
Modify  | 1.3715     | 1.3715     | 1.3715     |   0.0 |  0.37
Other   |            | 0.1649     |            |       |  0.04

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

Total # of neighbors = 385750
Ave neighs/atom = 48.21875
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 = 292.805582799129, Press = 1.20137022964159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -36232.772     -36232.772     -36533.093     -36533.093      290.4597       290.4597       158730.55      158730.55     -101.0028      -101.0028     
     21000  -36223.658     -36223.658     -36530.138     -36530.138      296.41607      296.41607      158681.54      158681.54     -5.3345942     -5.3345942    
Loop time of 370.113 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.38     | 368.38     | 368.38     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20423    | 0.20423    | 0.20423    |   0.0 |  0.06
Output  | 0.0002982  | 0.0002982  | 0.0002982  |   0.0 |  0.00
Modify  | 1.3631     | 1.3631     | 1.3631     |   0.0 |  0.37
Other   |            | 0.1655     |            |       |  0.04

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

Total # of neighbors = 385158
Ave neighs/atom = 48.14475
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 = 292.791324083749, Press = -0.399326985434438
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -36223.658     -36223.658     -36530.138     -36530.138      296.41607      296.41607      158681.54      158681.54     -5.3345942     -5.3345942    
     22000  -36227.865     -36227.865     -36532.787     -36532.787      294.90918      294.90918      158641.4       158641.4       200.66375      200.66375    
Loop time of 370.287 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.56     | 368.56     | 368.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20427    | 0.20427    | 0.20427    |   0.0 |  0.06
Output  | 0.00023522 | 0.00023522 | 0.00023522 |   0.0 |  0.00
Modify  | 1.3622     | 1.3622     | 1.3622     |   0.0 |  0.37
Other   |            | 0.1638     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6730 ave        6730 max        6730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       385906 ave      385906 max      385906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385906
Ave neighs/atom = 48.23825
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 = 292.815148992724, Press = -0.940939323605123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -36227.865     -36227.865     -36532.787     -36532.787      294.90918      294.90918      158641.4       158641.4       200.66375      200.66375    
     23000  -36235.54      -36235.54      -36535.595     -36535.595      290.20154      290.20154      158557.67      158557.67      648.08247      648.08247    
Loop time of 369.956 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.23     | 368.23     | 368.23     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20331    | 0.20331    | 0.20331    |   0.0 |  0.05
Output  | 0.00027172 | 0.00027172 | 0.00027172 |   0.0 |  0.00
Modify  | 1.3604     | 1.3604     | 1.3604     |   0.0 |  0.37
Other   |            | 0.1643     |            |       |  0.04

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

Total # of neighbors = 386120
Ave neighs/atom = 48.265
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 = 292.75447596539, Press = -0.187101393149826
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -36235.54      -36235.54      -36535.595     -36535.595      290.20154      290.20154      158557.67      158557.67      648.08247      648.08247    
     24000  -36225.556     -36225.556     -36531.507     -36531.507      295.90453      295.90453      158675.93      158675.93     -122.60722     -122.60722    
Loop time of 370.888 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.16     | 369.16     | 369.16     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20212    | 0.20212    | 0.20212    |   0.0 |  0.05
Output  | 0.00023695 | 0.00023695 | 0.00023695 |   0.0 |  0.00
Modify  | 1.3621     | 1.3621     | 1.3621     |   0.0 |  0.37
Other   |            | 0.1656     |            |       |  0.04

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

Total # of neighbors = 385920
Ave neighs/atom = 48.24
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 = 292.762151754725, Press = 0.874595601759626
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -36225.556     -36225.556     -36531.507     -36531.507      295.90453      295.90453      158675.93      158675.93     -122.60722     -122.60722    
     25000  -36230.359     -36230.359     -36535.89      -36535.89       295.49901      295.49901      158794.04      158794.04     -557.51407     -557.51407    
Loop time of 370.88 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.13     | 369.13     | 369.13     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20438    | 0.20438    | 0.20438    |   0.0 |  0.06
Output  | 0.00023036 | 0.00023036 | 0.00023036 |   0.0 |  0.00
Modify  | 1.3818     | 1.3818     | 1.3818     |   0.0 |  0.37
Other   |            | 0.1658     |            |       |  0.04

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

Total # of neighbors = 386170
Ave neighs/atom = 48.27125
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 = 292.793254576963, Press = -0.159647557316189
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -36230.359     -36230.359     -36535.89      -36535.89       295.49901      295.49901      158794.04      158794.04     -557.51407     -557.51407    
     26000  -36225.945     -36225.945     -36529.035     -36529.035      293.1374       293.1374       158829.74      158829.74     -552.95423     -552.95423    
Loop time of 369.54 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 367.81     | 367.81     | 367.81     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20301    | 0.20301    | 0.20301    |   0.0 |  0.05
Output  | 0.00023553 | 0.00023553 | 0.00023553 |   0.0 |  0.00
Modify  | 1.3659     | 1.3659     | 1.3659     |   0.0 |  0.37
Other   |            | 0.1644     |            |       |  0.04

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

Total # of neighbors = 385282
Ave neighs/atom = 48.16025
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 = 292.837535956273, Press = -1.9670399607131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -36225.945     -36225.945     -36529.035     -36529.035      293.1374       293.1374       158829.74      158829.74     -552.95423     -552.95423    
     27000  -36229.42      -36229.42      -36533.009     -36533.009      293.61945      293.61945      158471.12      158471.12      981.55773      981.55773    
Loop time of 370.723 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.98     | 368.98     | 368.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20407    | 0.20407    | 0.20407    |   0.0 |  0.06
Output  | 0.00024046 | 0.00024046 | 0.00024046 |   0.0 |  0.00
Modify  | 1.3739     | 1.3739     | 1.3739     |   0.0 |  0.37
Other   |            | 0.1659     |            |       |  0.04

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

Total # of neighbors = 384694
Ave neighs/atom = 48.08675
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 = 292.844982830346, Press = 0.295945679473275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -36229.42      -36229.42      -36533.009     -36533.009      293.61945      293.61945      158471.12      158471.12      981.55773      981.55773    
     28000  -36224.397     -36224.397     -36525.834     -36525.834      291.53893      291.53893      158786.03      158786.03     -501.17365     -501.17365    
Loop time of 370.915 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.17     | 369.17     | 369.17     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20451    | 0.20451    | 0.20451    |   0.0 |  0.06
Output  | 0.00023845 | 0.00023845 | 0.00023845 |   0.0 |  0.00
Modify  | 1.3781     | 1.3781     | 1.3781     |   0.0 |  0.37
Other   |            | 0.166      |            |       |  0.04

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

Total # of neighbors = 386826
Ave neighs/atom = 48.35325
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 = 292.862313433913, Press = 0.252112703203469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -36224.397     -36224.397     -36525.834     -36525.834      291.53893      291.53893      158786.03      158786.03     -501.17365     -501.17365    
     29000  -36227.028     -36227.028     -36536.346     -36536.346      299.16031      299.16031      158619.67      158619.67      434.18461      434.18461    
Loop time of 374.058 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.28     | 372.28     | 372.28     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20437    | 0.20437    | 0.20437    |   0.0 |  0.05
Output  | 0.00031103 | 0.00031103 | 0.00031103 |   0.0 |  0.00
Modify  | 1.4107     | 1.4107     | 1.4107     |   0.0 |  0.38
Other   |            | 0.1679     |            |       |  0.04

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

Total # of neighbors = 385658
Ave neighs/atom = 48.20725
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 = 292.818006528565, Press = -0.932336656268514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -36227.028     -36227.028     -36536.346     -36536.346      299.16031      299.16031      158619.67      158619.67      434.18461      434.18461    
     30000  -36231.645     -36231.645     -36532.612     -36532.612      291.08436      291.08436      158600.11      158600.11      391.80657      391.80657    
Loop time of 373.745 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.98     | 371.98     | 371.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20337    | 0.20337    | 0.20337    |   0.0 |  0.05
Output  | 0.00023239 | 0.00023239 | 0.00023239 |   0.0 |  0.00
Modify  | 1.3915     | 1.3915     | 1.3915     |   0.0 |  0.37
Other   |            | 0.1661     |            |       |  0.04

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

Total # of neighbors = 385692
Ave neighs/atom = 48.2115
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 = 292.83080107947, Press = -0.166602692016594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -36231.645     -36231.645     -36532.612     -36532.612      291.08436      291.08436      158600.11      158600.11      391.80657      391.80657    
     31000  -36231.126     -36231.126     -36531.466     -36531.466      290.47728      290.47728      158636.14      158636.14      83.148154      83.148154    
Loop time of 373.522 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.77     | 371.77     | 371.77     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20221    | 0.20221    | 0.20221    |   0.0 |  0.05
Output  | 0.0002314  | 0.0002314  | 0.0002314  |   0.0 |  0.00
Modify  | 1.3796     | 1.3796     | 1.3796     |   0.0 |  0.37
Other   |            | 0.1656     |            |       |  0.04

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

Total # of neighbors = 386430
Ave neighs/atom = 48.30375
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 = 292.872700491141, Press = 0.0104069107543068
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -36231.126     -36231.126     -36531.466     -36531.466      290.47728      290.47728      158636.14      158636.14      83.148154      83.148154    
     32000  -36225.739     -36225.739     -36528.447     -36528.447      292.76822      292.76822      158655.15      158655.15     -63.986992     -63.986992    
Loop time of 373.613 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.84     | 371.84     | 371.84     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20494    | 0.20494    | 0.20494    |   0.0 |  0.05
Output  | 0.00023124 | 0.00023124 | 0.00023124 |   0.0 |  0.00
Modify  | 1.3997     | 1.3997     | 1.3997     |   0.0 |  0.37
Other   |            | 0.1668     |            |       |  0.04

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

Total # of neighbors = 386118
Ave neighs/atom = 48.26475
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 = 292.88174909766, Press = -0.0594563441780763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -36225.739     -36225.739     -36528.447     -36528.447      292.76822      292.76822      158655.15      158655.15     -63.986992     -63.986992    
     33000  -36232.655     -36232.655     -36530.5       -36530.5        288.06471      288.06471      158683.9       158683.9      -33.341545     -33.341545    
Loop time of 372.817 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.06     | 371.06     | 371.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20187    | 0.20187    | 0.20187    |   0.0 |  0.05
Output  | 0.00024363 | 0.00024363 | 0.00024363 |   0.0 |  0.00
Modify  | 1.3863     | 1.3863     | 1.3863     |   0.0 |  0.37
Other   |            | 0.167      |            |       |  0.04

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

Total # of neighbors = 386406
Ave neighs/atom = 48.30075
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 = 292.903509811197, Press = -0.041838761289444
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -36232.655     -36232.655     -36530.5       -36530.5        288.06471      288.06471      158683.9       158683.9      -33.341545     -33.341545    
     34000  -36226.212     -36226.212     -36529.92      -36529.92       293.73498      293.73498      158680.43      158680.43     -131.01047     -131.01047    
Loop time of 371.422 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.68     | 369.68     | 369.68     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20334    | 0.20334    | 0.20334    |   0.0 |  0.05
Output  | 0.00023393 | 0.00023393 | 0.00023393 |   0.0 |  0.00
Modify  | 1.3738     | 1.3738     | 1.3738     |   0.0 |  0.37
Other   |            | 0.1654     |            |       |  0.04

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

Total # of neighbors = 386110
Ave neighs/atom = 48.26375
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 = 292.903873208277, Press = 0.264224073195723
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -36226.212     -36226.212     -36529.92      -36529.92       293.73498      293.73498      158680.43      158680.43     -131.01047     -131.01047    
     35000  -36234.056     -36234.056     -36532.429     -36532.429      288.57556      288.57556      158777.77      158777.77     -137.2355      -137.2355     
Loop time of 373.526 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.77     | 371.77     | 371.77     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20197    | 0.20197    | 0.20197    |   0.0 |  0.05
Output  | 0.00023247 | 0.00023247 | 0.00023247 |   0.0 |  0.00
Modify  | 1.3886     | 1.3886     | 1.3886     |   0.0 |  0.37
Other   |            | 0.1671     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6734 ave        6734 max        6734 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:       386122 ave      386122 max      386122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386122
Ave neighs/atom = 48.26525
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 = 292.869720380641, Press = -0.185222226621418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -36234.056     -36234.056     -36532.429     -36532.429      288.57556      288.57556      158777.77      158777.77     -137.2355      -137.2355     
     36000  -36227.379     -36227.379     -36532.987     -36532.987      295.57288      295.57288      158661.74      158661.74      192.46501      192.46501    
Loop time of 371.134 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.4      | 369.4      | 369.4      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20205    | 0.20205    | 0.20205    |   0.0 |  0.05
Output  | 0.00035631 | 0.00035631 | 0.00035631 |   0.0 |  0.00
Modify  | 1.3698     | 1.3698     | 1.3698     |   0.0 |  0.37
Other   |            | 0.1659     |            |       |  0.04

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

Total # of neighbors = 384714
Ave neighs/atom = 48.08925
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 = 292.884583646643, Press = 0.247354990752484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -36227.379     -36227.379     -36532.987     -36532.987      295.57288      295.57288      158661.74      158661.74      192.46501      192.46501    
     37000  -36224.745     -36224.745     -36524.142     -36524.142      289.56555      289.56555      158653.7       158653.7      -25.933105     -25.933105    
Loop time of 373.871 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.1      | 372.1      | 372.1      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20148    | 0.20148    | 0.20148    |   0.0 |  0.05
Output  | 0.00026876 | 0.00026876 | 0.00026876 |   0.0 |  0.00
Modify  | 1.3978     | 1.3978     | 1.3978     |   0.0 |  0.37
Other   |            | 0.1671     |            |       |  0.04

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

Total # of neighbors = 385408
Ave neighs/atom = 48.176
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 = 292.87025864787, Press = 0.258261619334998
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -36224.745     -36224.745     -36524.142     -36524.142      289.56555      289.56555      158653.7       158653.7      -25.933105     -25.933105    
     38000  -36226.48      -36226.48      -36529.05      -36529.05       292.63448      292.63448      158684.62      158684.62      28.407305      28.407305    
Loop time of 374.057 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.29     | 372.29     | 372.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20361    | 0.20361    | 0.20361    |   0.0 |  0.05
Output  | 0.00054384 | 0.00054384 | 0.00054384 |   0.0 |  0.00
Modify  | 1.3983     | 1.3983     | 1.3983     |   0.0 |  0.37
Other   |            | 0.1674     |            |       |  0.04

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

Total # of neighbors = 386026
Ave neighs/atom = 48.25325
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 = 292.85391709566, Press = -0.0813564435097349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -36226.48      -36226.48      -36529.05      -36529.05       292.63448      292.63448      158684.62      158684.62      28.407305      28.407305    
     39000  -36223.895     -36223.895     -36528.247     -36528.247      294.35773      294.35773      158736.45      158736.45     -203.80411     -203.80411    
Loop time of 373.546 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.78     | 371.78     | 371.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2039     | 0.2039     | 0.2039     |   0.0 |  0.05
Output  | 0.00023643 | 0.00023643 | 0.00023643 |   0.0 |  0.00
Modify  | 1.3942     | 1.3942     | 1.3942     |   0.0 |  0.37
Other   |            | 0.1664     |            |       |  0.04

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

Total # of neighbors = 385520
Ave neighs/atom = 48.19
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 = 292.847564811544, Press = -0.0290695418764328
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -36223.895     -36223.895     -36528.247     -36528.247      294.35773      294.35773      158736.45      158736.45     -203.80411     -203.80411    
     40000  -36225.313     -36225.313     -36531.648     -36531.648      296.27522      296.27522      158757.73      158757.73     -51.573022     -51.573022    
Loop time of 372.162 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.42     | 370.42     | 370.42     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20236    | 0.20236    | 0.20236    |   0.0 |  0.05
Output  | 0.00023673 | 0.00023673 | 0.00023673 |   0.0 |  0.00
Modify  | 1.3753     | 1.3753     | 1.3753     |   0.0 |  0.37
Other   |            | 0.1661     |            |       |  0.04

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

Total # of neighbors = 385440
Ave neighs/atom = 48.18
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 = 292.89372832134, Press = 0.680153957199856
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -36225.313     -36225.313     -36531.648     -36531.648      296.27522      296.27522      158757.73      158757.73     -51.573022     -51.573022    
     41000  -36228.464     -36228.464     -36535.021     -36535.021      296.49034      296.49034      158747.47      158747.47      61.273308      61.273308    
Loop time of 371.309 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.56     | 369.56     | 369.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20136    | 0.20136    | 0.20136    |   0.0 |  0.05
Output  | 0.00027391 | 0.00027391 | 0.00027391 |   0.0 |  0.00
Modify  | 1.3822     | 1.3822     | 1.3822     |   0.0 |  0.37
Other   |            | 0.1666     |            |       |  0.04

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

Total # of neighbors = 385058
Ave neighs/atom = 48.13225
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 = 292.902865210197, Press = -0.398189778617767
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -36228.464     -36228.464     -36535.021     -36535.021      296.49034      296.49034      158747.47      158747.47      61.273308      61.273308    
     42000  -36234.212     -36234.212     -36535.349     -36535.349      291.24872      291.24872      158774.29      158774.29     -289.707       -289.707      
Loop time of 371.989 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.24     | 370.24     | 370.24     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20121    | 0.20121    | 0.20121    |   0.0 |  0.05
Output  | 0.00024366 | 0.00024366 | 0.00024366 |   0.0 |  0.00
Modify  | 1.3786     | 1.3786     | 1.3786     |   0.0 |  0.37
Other   |            | 0.1658     |            |       |  0.04

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

Total # of neighbors = 384532
Ave neighs/atom = 48.0665
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 = 292.907778231969, Press = -0.412576481216759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -36234.212     -36234.212     -36535.349     -36535.349      291.24872      291.24872      158774.29      158774.29     -289.707       -289.707      
     43000  -36227.073     -36227.073     -36532.99      -36532.99       295.8721       295.8721       158483.44      158483.44      1004.8813      1004.8813    
Loop time of 371.226 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.49     | 369.49     | 369.49     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19941    | 0.19941    | 0.19941    |   0.0 |  0.05
Output  | 0.00023902 | 0.00023902 | 0.00023902 |   0.0 |  0.00
Modify  | 1.372      | 1.372      | 1.372      |   0.0 |  0.37
Other   |            | 0.1657     |            |       |  0.04

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

Total # of neighbors = 384774
Ave neighs/atom = 48.09675
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 = 292.885444307172, Press = 0.260361915869943
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -36227.073     -36227.073     -36532.99      -36532.99       295.8721       295.8721       158483.44      158483.44      1004.8813      1004.8813    
     44000  -36234.983     -36234.983     -36537.27      -36537.27       292.36054      292.36054      158669.94      158669.94      414.92646      414.92646    
Loop time of 373.936 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.17     | 372.17     | 372.17     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20136    | 0.20136    | 0.20136    |   0.0 |  0.05
Output  | 0.00023009 | 0.00023009 | 0.00023009 |   0.0 |  0.00
Modify  | 1.3977     | 1.3977     | 1.3977     |   0.0 |  0.37
Other   |            | 0.168      |            |       |  0.04

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

Total # of neighbors = 386430
Ave neighs/atom = 48.30375
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 = 292.874892974488, Press = 0.694208313535384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -36234.983     -36234.983     -36537.27      -36537.27       292.36054      292.36054      158669.94      158669.94      414.92646      414.92646    
     45000  -36226.629     -36226.629     -36532.649     -36532.649      295.97199      295.97199      158724.14      158724.14      16.956947      16.956947    
Loop time of 373.308 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.54     | 371.54     | 371.54     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20151    | 0.20151    | 0.20151    |   0.0 |  0.05
Output  | 0.00024089 | 0.00024089 | 0.00024089 |   0.0 |  0.00
Modify  | 1.3947     | 1.3947     | 1.3947     |   0.0 |  0.37
Other   |            | 0.1673     |            |       |  0.04

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

Total # of neighbors = 385008
Ave neighs/atom = 48.126
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 = 292.853284284023, Press = -0.148019685540373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -36226.629     -36226.629     -36532.649     -36532.649      295.97199      295.97199      158724.14      158724.14      16.956947      16.956947    
     46000  -36225.616     -36225.616     -36535.101     -36535.101      299.32165      299.32165      158661.53      158661.53      122.23709      122.23709    
Loop time of 373.534 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.77     | 371.77     | 371.77     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20495    | 0.20495    | 0.20495    |   0.0 |  0.05
Output  | 0.00023309 | 0.00023309 | 0.00023309 |   0.0 |  0.00
Modify  | 1.3909     | 1.3909     | 1.3909     |   0.0 |  0.37
Other   |            | 0.1679     |            |       |  0.04

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

Total # of neighbors = 384962
Ave neighs/atom = 48.12025
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 = 292.883640096489, Press = -0.087361524485739
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -36225.616     -36225.616     -36535.101     -36535.101      299.32165      299.32165      158661.53      158661.53      122.23709      122.23709    
     47000  -36226.774     -36226.774     -36528.304     -36528.304      291.62872      291.62872      158729.97      158729.97     -145.92322     -145.92322    
Loop time of 371.535 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.8      | 369.8      | 369.8      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19801    | 0.19801    | 0.19801    |   0.0 |  0.05
Output  | 0.00027739 | 0.00027739 | 0.00027739 |   0.0 |  0.00
Modify  | 1.3684     | 1.3684     | 1.3684     |   0.0 |  0.37
Other   |            | 0.1648     |            |       |  0.04

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

Total # of neighbors = 385476
Ave neighs/atom = 48.1845
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 = 292.896015673044, Press = -0.0516812517973308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -36226.774     -36226.774     -36528.304     -36528.304      291.62872      291.62872      158729.97      158729.97     -145.92322     -145.92322    
     48000  -36233.482     -36233.482     -36533.05      -36533.05       289.73099      289.73099      158936.23      158936.23     -1239.554      -1239.554     
Loop time of 371.773 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.03     | 370.03     | 370.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19943    | 0.19943    | 0.19943    |   0.0 |  0.05
Output  | 0.0003104  | 0.0003104  | 0.0003104  |   0.0 |  0.00
Modify  | 1.3801     | 1.3801     | 1.3801     |   0.0 |  0.37
Other   |            | 0.1659     |            |       |  0.04

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

Total # of neighbors = 385446
Ave neighs/atom = 48.18075
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 = 292.905941770842, Press = -0.372502078065478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -36233.482     -36233.482     -36533.05      -36533.05       289.73099      289.73099      158936.23      158936.23     -1239.554      -1239.554     
     49000  -36225.459     -36225.459     -36527.519     -36527.519      292.14205      292.14205      158642.82      158642.82      253.63514      253.63514    
Loop time of 372.652 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.9      | 370.9      | 370.9      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20001    | 0.20001    | 0.20001    |   0.0 |  0.05
Output  | 0.00035852 | 0.00035852 | 0.00035852 |   0.0 |  0.00
Modify  | 1.3905     | 1.3905     | 1.3905     |   0.0 |  0.37
Other   |            | 0.1661     |            |       |  0.04

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

Total # of neighbors = 384510
Ave neighs/atom = 48.06375
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 = 292.891896887434, Press = -0.296983941006427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -36225.459     -36225.459     -36527.519     -36527.519      292.14205      292.14205      158642.82      158642.82      253.63514      253.63514    
     50000  -36233.56      -36233.56      -36532.792     -36532.792      289.40627      289.40627      158589.8       158589.8       633.49116      633.49116    
Loop time of 374.415 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.65     | 372.65     | 372.65     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20026    | 0.20026    | 0.20026    |   0.0 |  0.05
Output  | 0.00023938 | 0.00023938 | 0.00023938 |   0.0 |  0.00
Modify  | 1.4003     | 1.4003     | 1.4003     |   0.0 |  0.37
Other   |            | 0.1673     |            |       |  0.04

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

Total # of neighbors = 386040
Ave neighs/atom = 48.255
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 = 292.878664686825, Press = 0.48306810939671
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -36233.56      -36233.56      -36532.792     -36532.792      289.40627      289.40627      158589.8       158589.8       633.49116      633.49116    
     51000  -36227.426     -36227.426     -36532.377     -36532.377      294.9376       294.9376       158728.96      158728.96     -151.92604     -151.92604    
Loop time of 371.416 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.67     | 369.67     | 369.67     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19821    | 0.19821    | 0.19821    |   0.0 |  0.05
Output  | 0.00023228 | 0.00023228 | 0.00023228 |   0.0 |  0.00
Modify  | 1.3802     | 1.3802     | 1.3802     |   0.0 |  0.37
Other   |            | 0.1673     |            |       |  0.05

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

Total # of neighbors = 385992
Ave neighs/atom = 48.249
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 = 292.881829645777, Press = 0.0296845260701741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -36227.426     -36227.426     -36532.377     -36532.377      294.9376       294.9376       158728.96      158728.96     -151.92604     -151.92604    
     52000  -36230.407     -36230.407     -36534.206     -36534.206      293.823        293.823        158702.21      158702.21      135.16425      135.16425    
Loop time of 370.578 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 102.938 hours/ns, 2.698 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.84     | 368.84     | 368.84     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19671    | 0.19671    | 0.19671    |   0.0 |  0.05
Output  | 0.00023027 | 0.00023027 | 0.00023027 |   0.0 |  0.00
Modify  | 1.3711     | 1.3711     | 1.3711     |   0.0 |  0.37
Other   |            | 0.1669     |            |       |  0.05

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

Total # of neighbors = 385442
Ave neighs/atom = 48.18025
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 = 292.886106035401, Press = -0.0642683612393407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -36230.407     -36230.407     -36534.206     -36534.206      293.823        293.823        158702.21      158702.21      135.16425      135.16425    
     53000  -36233.535     -36233.535     -36531.855     -36531.855      288.52416      288.52416      158637.8       158637.8       320.52237      320.52237    
Loop time of 370.552 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.82     | 368.82     | 368.82     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19884    | 0.19884    | 0.19884    |   0.0 |  0.05
Output  | 0.00022971 | 0.00022971 | 0.00022971 |   0.0 |  0.00
Modify  | 1.3661     | 1.3661     | 1.3661     |   0.0 |  0.37
Other   |            | 0.1646     |            |       |  0.04

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

Total # of neighbors = 385224
Ave neighs/atom = 48.153
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 = 292.856882122751, Press = -0.0145662195759714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -36233.535     -36233.535     -36531.855     -36531.855      288.52416      288.52416      158637.8       158637.8       320.52237      320.52237    
     54000  -36228.038     -36228.038     -36531.761     -36531.761      293.7496       293.7496       158600.07      158600.07      429.61854      429.61854    
Loop time of 373.665 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.91     | 371.91     | 371.91     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19904    | 0.19904    | 0.19904    |   0.0 |  0.05
Output  | 0.0002349  | 0.0002349  | 0.0002349  |   0.0 |  0.00
Modify  | 1.3907     | 1.3907     | 1.3907     |   0.0 |  0.37
Other   |            | 0.1667     |            |       |  0.04

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

Total # of neighbors = 385972
Ave neighs/atom = 48.2465
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 = 292.859312447887, Press = 0.39983469286158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -36228.038     -36228.038     -36531.761     -36531.761      293.7496       293.7496       158600.07      158600.07      429.61854      429.61854    
     55000  -36227.836     -36227.836     -36532.004     -36532.004      294.17998      294.17998      158768.94      158768.94     -411.54402     -411.54402    
Loop time of 370.484 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.75     | 368.75     | 368.75     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1971     | 0.1971     | 0.1971     |   0.0 |  0.05
Output  | 0.00023536 | 0.00023536 | 0.00023536 |   0.0 |  0.00
Modify  | 1.37       | 1.37       | 1.37       |   0.0 |  0.37
Other   |            | 0.1666     |            |       |  0.04

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

Total # of neighbors = 385838
Ave neighs/atom = 48.22975
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 = 292.841213812493, Press = -0.0552422869948791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -36227.836     -36227.836     -36532.004     -36532.004      294.17998      294.17998      158768.94      158768.94     -411.54402     -411.54402    
     56000  -36231.059     -36231.059     -36533.93      -36533.93       292.92553      292.92553      158745.52      158745.52     -117.0407      -117.0407     
Loop time of 370.239 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.51     | 368.51     | 368.51     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19632    | 0.19632    | 0.19632    |   0.0 |  0.05
Output  | 0.00023136 | 0.00023136 | 0.00023136 |   0.0 |  0.00
Modify  | 1.3637     | 1.3637     | 1.3637     |   0.0 |  0.37
Other   |            | 0.1656     |            |       |  0.04

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

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

Performance: 0.235 ns/day, 102.304 hours/ns, 2.715 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 366.57     | 366.57     | 366.57     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1966     | 0.1966     | 0.1966     |   0.0 |  0.05
Output  | 0.00027312 | 0.00027312 | 0.00027312 |   0.0 |  0.00
Modify  | 1.3619     | 1.3619     | 1.3619     |   0.0 |  0.37
Other   |            | 0.1649     |            |       |  0.04

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

Total # of neighbors = 385100
Ave neighs/atom = 48.1375
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 = 292.810487437298, Press = 0.247021166387492
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -36227.382     -36227.382     -36532.965     -36532.965      295.549        295.549        158671.48      158671.48      71.723522      71.723522    
     58000  -36234.926     -36234.926     -36536.399     -36536.399      291.57359      291.57359      158834.65      158834.65     -501.10485     -501.10485    
Loop time of 372.726 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.98     | 370.98     | 370.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19746    | 0.19746    | 0.19746    |   0.0 |  0.05
Output  | 0.00030594 | 0.00030594 | 0.00030594 |   0.0 |  0.00
Modify  | 1.3826     | 1.3826     | 1.3826     |   0.0 |  0.37
Other   |            | 0.1657     |            |       |  0.04

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

Total # of neighbors = 385728
Ave neighs/atom = 48.216
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 = 292.80747546014, Press = -0.212939884859706
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -36234.926     -36234.926     -36536.399     -36536.399      291.57359      291.57359      158834.65      158834.65     -501.10485     -501.10485    
     59000  -36227.989     -36227.989     -36531.926     -36531.926      293.95715      293.95715      158851.15      158851.15     -628.96739     -628.96739    
Loop time of 369.445 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.234 ns/day, 102.624 hours/ns, 2.707 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 367.72     | 367.72     | 367.72     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19549    | 0.19549    | 0.19549    |   0.0 |  0.05
Output  | 0.00027682 | 0.00027682 | 0.00027682 |   0.0 |  0.00
Modify  | 1.3623     | 1.3623     | 1.3623     |   0.0 |  0.37
Other   |            | 0.1655     |            |       |  0.04

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

Total # of neighbors = 384530
Ave neighs/atom = 48.06625
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 = 292.810333868292, Press = -0.421356550836162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -36227.989     -36227.989     -36531.926     -36531.926      293.95715      293.95715      158851.15      158851.15     -628.96739     -628.96739    
     60000  -36224.383     -36224.383     -36526.358     -36526.358      292.05862      292.05862      158699.3       158699.3      -240.33587     -240.33587    
Loop time of 370.974 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.048 hours/ns, 2.696 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.23     | 369.23     | 369.23     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19795    | 0.19795    | 0.19795    |   0.0 |  0.05
Output  | 0.00029559 | 0.00029559 | 0.00029559 |   0.0 |  0.00
Modify  | 1.3764     | 1.3764     | 1.3764     |   0.0 |  0.37
Other   |            | 0.1663     |            |       |  0.04

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

Total # of neighbors = 384840
Ave neighs/atom = 48.105
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 = 292.816761317639, Press = -0.212156719551418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -36224.383     -36224.383     -36526.358     -36526.358      292.05862      292.05862      158699.3       158699.3      -240.33587     -240.33587    
     61000  -36227.711     -36227.711     -36530.443     -36530.443      292.79168      292.79168      158807.6       158807.6      -595.25049     -595.25049    
Loop time of 370.924 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.034 hours/ns, 2.696 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.19     | 369.19     | 369.19     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19602    | 0.19602    | 0.19602    |   0.0 |  0.05
Output  | 0.00023762 | 0.00023762 | 0.00023762 |   0.0 |  0.00
Modify  | 1.3714     | 1.3714     | 1.3714     |   0.0 |  0.37
Other   |            | 0.1655     |            |       |  0.04

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

Total # of neighbors = 386274
Ave neighs/atom = 48.28425
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 = 292.837952928718, Press = 0.0632633387224897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -36227.711     -36227.711     -36530.443     -36530.443      292.79168      292.79168      158807.6       158807.6      -595.25049     -595.25049    
     62000  -36235.223     -36235.223     -36532.819     -36532.819      287.82352      287.82352      158651.82      158651.82      238.54753      238.54753    
Loop time of 370.008 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.29     | 368.29     | 368.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1958     | 0.1958     | 0.1958     |   0.0 |  0.05
Output  | 0.00028144 | 0.00028144 | 0.00028144 |   0.0 |  0.00
Modify  | 1.3601     | 1.3601     | 1.3601     |   0.0 |  0.37
Other   |            | 0.1652     |            |       |  0.04

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

Total # of neighbors = 385302
Ave neighs/atom = 48.16275
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 = 292.825339816372, Press = -0.195951903405231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -36235.223     -36235.223     -36532.819     -36532.819      287.82352      287.82352      158651.82      158651.82      238.54753      238.54753    
     63000  -36226.498     -36226.498     -36530.249     -36530.249      293.77601      293.77601      158714.6       158714.6      -193.70694     -193.70694    
Loop time of 374.315 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.55     | 372.55     | 372.55     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19812    | 0.19812    | 0.19812    |   0.0 |  0.05
Output  | 0.0003514  | 0.0003514  | 0.0003514  |   0.0 |  0.00
Modify  | 1.394      | 1.394      | 1.394      |   0.0 |  0.37
Other   |            | 0.1675     |            |       |  0.04

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

Total # of neighbors = 385746
Ave neighs/atom = 48.21825
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 = 292.818311878325, Press = -0.155051623231403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -36226.498     -36226.498     -36530.249     -36530.249      293.77601      293.77601      158714.6       158714.6      -193.70694     -193.70694    
     64000  -36233.077     -36233.077     -36535.077     -36535.077      292.08403      292.08403      158744.71      158744.71     -167.18583     -167.18583    
Loop time of 370.6 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.87     | 368.87     | 368.87     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19798    | 0.19798    | 0.19798    |   0.0 |  0.05
Output  | 0.00027889 | 0.00027889 | 0.00027889 |   0.0 |  0.00
Modify  | 1.3688     | 1.3688     | 1.3688     |   0.0 |  0.37
Other   |            | 0.1654     |            |       |  0.04

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

Total # of neighbors = 385656
Ave neighs/atom = 48.207
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 = 292.811388906057, Press = -0.281363042579976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -36233.077     -36233.077     -36535.077     -36535.077      292.08403      292.08403      158744.71      158744.71     -167.18583     -167.18583    
     65000  -36226.775     -36226.775     -36528.618     -36528.618      291.93109      291.93109      158570.73      158570.73      559.18223      559.18223    
Loop time of 371.742 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.99     | 369.99     | 369.99     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19812    | 0.19812    | 0.19812    |   0.0 |  0.05
Output  | 0.00036467 | 0.00036467 | 0.00036467 |   0.0 |  0.00
Modify  | 1.3842     | 1.3842     | 1.3842     |   0.0 |  0.37
Other   |            | 0.167      |            |       |  0.04

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

Total # of neighbors = 385314
Ave neighs/atom = 48.16425
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 = 292.801045631369, Press = -0.137622207866801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -36226.775     -36226.775     -36528.618     -36528.618      291.93109      291.93109      158570.73      158570.73      559.18223      559.18223    
     66000  -36234.593     -36234.593     -36534.339     -36534.339      289.90268      289.90268      158573.59      158573.59      619.13744      619.13744    
Loop time of 371.967 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.23     | 370.23     | 370.23     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19748    | 0.19748    | 0.19748    |   0.0 |  0.05
Output  | 0.00022821 | 0.00022821 | 0.00022821 |   0.0 |  0.00
Modify  | 1.375      | 1.375      | 1.375      |   0.0 |  0.37
Other   |            | 0.1663     |            |       |  0.04

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

Total # of neighbors = 386180
Ave neighs/atom = 48.2725
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 = 292.794735357457, Press = 0.155845416622183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -36234.593     -36234.593     -36534.339     -36534.339      289.90268      289.90268      158573.59      158573.59      619.13744      619.13744    
     67000  -36229.032     -36229.032     -36529.301     -36529.301      290.40919      290.40919      158772.52      158772.52     -460.44694     -460.44694    
Loop time of 370.06 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.33     | 368.33     | 368.33     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19718    | 0.19718    | 0.19718    |   0.0 |  0.05
Output  | 0.00023685 | 0.00023685 | 0.00023685 |   0.0 |  0.00
Modify  | 1.3635     | 1.3635     | 1.3635     |   0.0 |  0.37
Other   |            | 0.1657     |            |       |  0.04

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

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

Performance: 0.233 ns/day, 102.899 hours/ns, 2.700 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.7      | 368.7      | 368.7      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.197      | 0.197      | 0.197      |   0.0 |  0.05
Output  | 0.00022965 | 0.00022965 | 0.00022965 |   0.0 |  0.00
Modify  | 1.3693     | 1.3693     | 1.3693     |   0.0 |  0.37
Other   |            | 0.1664     |            |       |  0.04

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

Total # of neighbors = 385430
Ave neighs/atom = 48.17875
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 = 292.810435424288, Press = -0.158682422977381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -36220.973     -36220.973     -36527.99      -36527.99       296.93563      296.93563      158829.27      158829.27     -723.23371     -723.23371    
     69000  -36228.258     -36228.258     -36529.827     -36529.827      291.66722      291.66722      158770.34      158770.34     -193.54856     -193.54856    
Loop time of 370.128 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.41     | 368.41     | 368.41     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19644    | 0.19644    | 0.19644    |   0.0 |  0.05
Output  | 0.00027875 | 0.00027875 | 0.00027875 |   0.0 |  0.00
Modify  | 1.3605     | 1.3605     | 1.3605     |   0.0 |  0.37
Other   |            | 0.1652     |            |       |  0.04

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

Total # of neighbors = 385266
Ave neighs/atom = 48.15825
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 = 292.828911332, Press = -0.265869494347913
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -36228.258     -36228.258     -36529.827     -36529.827      291.66722      291.66722      158770.34      158770.34     -193.54856     -193.54856    
     70000  -36228.057     -36228.057     -36533.841     -36533.841      295.74258      295.74258      158612.52      158612.52      572.78229      572.78229    
Loop time of 371.417 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.69     | 369.69     | 369.69     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19693    | 0.19693    | 0.19693    |   0.0 |  0.05
Output  | 0.00023195 | 0.00023195 | 0.00023195 |   0.0 |  0.00
Modify  | 1.3676     | 1.3676     | 1.3676     |   0.0 |  0.37
Other   |            | 0.1659     |            |       |  0.04

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

Total # of neighbors = 385098
Ave neighs/atom = 48.13725
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 = 292.831653518947, Press = -0.224643526730728
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -36228.057     -36228.057     -36533.841     -36533.841      295.74258      295.74258      158612.52      158612.52      572.78229      572.78229    
     71000  -36226.749     -36226.749     -36532.736     -36532.736      295.93934      295.93934      158600.86      158600.86      678.19506      678.19506    
Loop time of 372.915 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.587 hours/ns, 2.682 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.17     | 371.17     | 371.17     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19843    | 0.19843    | 0.19843    |   0.0 |  0.05
Output  | 0.0002312  | 0.0002312  | 0.0002312  |   0.0 |  0.00
Modify  | 1.3849     | 1.3849     | 1.3849     |   0.0 |  0.37
Other   |            | 0.1661     |            |       |  0.04

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

Total # of neighbors = 385778
Ave neighs/atom = 48.22225
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 = 292.817156317148, Press = 0.00966482874666198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -36226.749     -36226.749     -36532.736     -36532.736      295.93934      295.93934      158600.86      158600.86      678.19506      678.19506    
     72000  -36229.202     -36229.202     -36531.954     -36531.954      292.81041      292.81041      158763.7       158763.7      -281.44146     -281.44146    
Loop time of 369.152 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.234 ns/day, 102.542 hours/ns, 2.709 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 367.43     | 367.43     | 367.43     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19588    | 0.19588    | 0.19588    |   0.0 |  0.05
Output  | 0.0002516  | 0.0002516  | 0.0002516  |   0.0 |  0.00
Modify  | 1.3592     | 1.3592     | 1.3592     |   0.0 |  0.37
Other   |            | 0.1646     |            |       |  0.04

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

Total # of neighbors = 385386
Ave neighs/atom = 48.17325
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 = 292.826224601167, Press = -0.0830002421920703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -36229.202     -36229.202     -36531.954     -36531.954      292.81041      292.81041      158763.7       158763.7      -281.44146     -281.44146    
     73000  -36220.594     -36220.594     -36527.184     -36527.184      296.52268      296.52268      158586.05      158586.05      527.78825      527.78825    
Loop time of 372.723 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.98     | 370.98     | 370.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19721    | 0.19721    | 0.19721    |   0.0 |  0.05
Output  | 0.00027983 | 0.00027983 | 0.00027983 |   0.0 |  0.00
Modify  | 1.3754     | 1.3754     | 1.3754     |   0.0 |  0.37
Other   |            | 0.1662     |            |       |  0.04

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

Total # of neighbors = 385222
Ave neighs/atom = 48.15275
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 = 292.842056825469, Press = -0.288223543650656
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -36220.594     -36220.594     -36527.184     -36527.184      296.52268      296.52268      158586.05      158586.05      527.78825      527.78825    
     74000  -36230.461     -36230.461     -36531.859     -36531.859      291.50141      291.50141      158639.85      158639.85      106.66332      106.66332    
Loop time of 371.153 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.42     | 369.42     | 369.42     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19757    | 0.19757    | 0.19757    |   0.0 |  0.05
Output  | 0.00039271 | 0.00039271 | 0.00039271 |   0.0 |  0.00
Modify  | 1.3643     | 1.3643     | 1.3643     |   0.0 |  0.37
Other   |            | 0.1655     |            |       |  0.04

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6730 ave        6730 max        6730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       386350 ave      386350 max      386350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386350
Ave neighs/atom = 48.29375
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 = 292.846356271072, Press = 0.0789192542695218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -36230.461     -36230.461     -36531.859     -36531.859      291.50141      291.50141      158639.85      158639.85      106.66332      106.66332    
     75000  -36231.436     -36231.436     -36533.543     -36533.543      292.18641      292.18641      158849.72      158849.72     -777.50798     -777.50798    
Loop time of 371.96 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.23     | 370.23     | 370.23     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1968     | 0.1968     | 0.1968     |   0.0 |  0.05
Output  | 0.00032581 | 0.00032581 | 0.00032581 |   0.0 |  0.00
Modify  | 1.372      | 1.372      | 1.372      |   0.0 |  0.37
Other   |            | 0.1643     |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.72     | 371.72     | 371.72     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19936    | 0.19936    | 0.19936    |   0.0 |  0.05
Output  | 0.00023772 | 0.00023772 | 0.00023772 |   0.0 |  0.00
Modify  | 1.3826     | 1.3826     | 1.3826     |   0.0 |  0.37
Other   |            | 0.168      |            |       |  0.04

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

Total # of neighbors = 384896
Ave neighs/atom = 48.112
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 = 292.853046122587, Press = -0.214177339906332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -36224.987     -36224.987     -36529.117     -36529.117      294.14348      294.14348      158697.65      158697.65     -198.46287     -198.46287    
     77000  -36235.481     -36235.481     -36536.668     -36536.668      291.2974       291.2974       158677.63      158677.63      257.13027      257.13027    
Loop time of 373.559 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 103.766 hours/ns, 2.677 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.8      | 371.8      | 371.8      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19693    | 0.19693    | 0.19693    |   0.0 |  0.05
Output  | 0.00035143 | 0.00035143 | 0.00035143 |   0.0 |  0.00
Modify  | 1.39       | 1.39       | 1.39       |   0.0 |  0.37
Other   |            | 0.1683     |            |       |  0.05

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

Total # of neighbors = 385912
Ave neighs/atom = 48.239
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 = 292.840675794822, Press = -0.0816316766002491
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -36235.481     -36235.481     -36536.668     -36536.668      291.2974       291.2974       158677.63      158677.63      257.13027      257.13027    
     78000  -36222.642     -36222.642     -36529.068     -36529.068      296.36453      296.36453      158517.48      158517.48      807.82691      807.82691    
Loop time of 370.714 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.98     | 368.98     | 368.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19685    | 0.19685    | 0.19685    |   0.0 |  0.05
Output  | 0.0002323  | 0.0002323  | 0.0002323  |   0.0 |  0.00
Modify  | 1.3704     | 1.3704     | 1.3704     |   0.0 |  0.37
Other   |            | 0.1662     |            |       |  0.04

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

Total # of neighbors = 385362
Ave neighs/atom = 48.17025
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 = 292.845408826295, Press = -0.217297950190568
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -36222.642     -36222.642     -36529.068     -36529.068      296.36453      296.36453      158517.48      158517.48      807.82691      807.82691    
     79000  -36230.329     -36230.329     -36533.359     -36533.359      293.07968      293.07968      158591.58      158591.58      630.61448      630.61448    
Loop time of 371.329 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.59     | 369.59     | 369.59     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19816    | 0.19816    | 0.19816    |   0.0 |  0.05
Output  | 0.00022861 | 0.00022861 | 0.00022861 |   0.0 |  0.00
Modify  | 1.3749     | 1.3749     | 1.3749     |   0.0 |  0.37
Other   |            | 0.166      |            |       |  0.04

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

Total # of neighbors = 386562
Ave neighs/atom = 48.32025
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 = 292.860837776542, Press = -0.0131489056850646
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -36230.329     -36230.329     -36533.359     -36533.359      293.07968      293.07968      158591.58      158591.58      630.61448      630.61448    
     80000  -36218.531     -36218.531     -36524.213     -36524.213      295.64482      295.64482      158596.65      158596.65      197.84477      197.84477    
Loop time of 373.092 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.35     | 371.35     | 371.35     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19588    | 0.19588    | 0.19588    |   0.0 |  0.05
Output  | 0.0002316  | 0.0002316  | 0.0002316  |   0.0 |  0.00
Modify  | 1.3815     | 1.3815     | 1.3815     |   0.0 |  0.37
Other   |            | 0.1665     |            |       |  0.04

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

Total # of neighbors = 385834
Ave neighs/atom = 48.22925
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 = 292.877122581912, Press = 0.0786046336481633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -36218.531     -36218.531     -36524.213     -36524.213      295.64482      295.64482      158596.65      158596.65      197.84477      197.84477    
     81000  -36228.611     -36228.611     -36529.27      -36529.27       290.78631      290.78631      158664.25      158664.25     -88.289775     -88.289775    
Loop time of 373.751 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372        | 372        | 372        |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20001    | 0.20001    | 0.20001    |   0.0 |  0.05
Output  | 0.0002273  | 0.0002273  | 0.0002273  |   0.0 |  0.00
Modify  | 1.385      | 1.385      | 1.385      |   0.0 |  0.37
Other   |            | 0.1665     |            |       |  0.04

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

Total # of neighbors = 386888
Ave neighs/atom = 48.361
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 = 292.885074525173, Press = -0.0996432693751592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -36228.611     -36228.611     -36529.27      -36529.27       290.78631      290.78631      158664.25      158664.25     -88.289775     -88.289775    
     82000  -36228.848     -36228.848     -36528.382     -36528.382      289.69911      289.69911      158724.97      158724.97      9.9202309      9.9202309    
Loop time of 371.826 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.285 hours/ns, 2.689 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.08     | 370.08     | 370.08     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19713    | 0.19713    | 0.19713    |   0.0 |  0.05
Output  | 0.0002309  | 0.0002309  | 0.0002309  |   0.0 |  0.00
Modify  | 1.3802     | 1.3802     | 1.3802     |   0.0 |  0.37
Other   |            | 0.1676     |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.84     | 368.84     | 368.84     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19741    | 0.19741    | 0.19741    |   0.0 |  0.05
Output  | 0.00027896 | 0.00027896 | 0.00027896 |   0.0 |  0.00
Modify  | 1.3685     | 1.3685     | 1.3685     |   0.0 |  0.37
Other   |            | 0.1649     |            |       |  0.04

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

Total # of neighbors = 384928
Ave neighs/atom = 48.116
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 = 292.894793879392, Press = -0.0883191163141073
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -36227.378     -36227.378     -36531.555     -36531.555      294.18883      294.18883      158659.18      158659.18      74.453363      74.453363    
     84000  -36224.775     -36224.775     -36527.334     -36527.334      292.62386      292.62386      158572.04      158572.04      446.48539      446.48539    
Loop time of 370.1 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.38     | 368.38     | 368.38     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19451    | 0.19451    | 0.19451    |   0.0 |  0.05
Output  | 0.00023298 | 0.00023298 | 0.00023298 |   0.0 |  0.00
Modify  | 1.3583     | 1.3583     | 1.3583     |   0.0 |  0.37
Other   |            | 0.1647     |            |       |  0.04

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

Total # of neighbors = 385656
Ave neighs/atom = 48.207
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 = 292.896698981096, Press = -0.09842129347481
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -36224.775     -36224.775     -36527.334     -36527.334      292.62386      292.62386      158572.04      158572.04      446.48539      446.48539    
     85000  -36226.05      -36226.05      -36530.791     -36530.791      294.73407      294.73407      158743.48      158743.48     -295.79205     -295.79205    
Loop time of 372.079 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.34     | 370.34     | 370.34     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19565    | 0.19565    | 0.19565    |   0.0 |  0.05
Output  | 0.0002321  | 0.0002321  | 0.0002321  |   0.0 |  0.00
Modify  | 1.3732     | 1.3732     | 1.3732     |   0.0 |  0.37
Other   |            | 0.1675     |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.7      | 371.7      | 371.7      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.198      | 0.198      | 0.198      |   0.0 |  0.05
Output  | 0.00023701 | 0.00023701 | 0.00023701 |   0.0 |  0.00
Modify  | 1.3977     | 1.3977     | 1.3977     |   0.0 |  0.37
Other   |            | 0.1668     |            |       |  0.04

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

Total # of neighbors = 385462
Ave neighs/atom = 48.18275
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 = 292.884793175948, Press = -0.133660258123154
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -36231.465     -36231.465     -36535.812     -36535.812      294.35387      294.35387      158622.45      158622.45      394.31256      394.31256    
     87000  -36224.986     -36224.986     -36529.538     -36529.538      294.5512       294.5512       158725.71      158725.71     -272.42121     -272.42121    
Loop time of 373.209 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.45     | 371.45     | 371.45     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19953    | 0.19953    | 0.19953    |   0.0 |  0.05
Output  | 0.00023274 | 0.00023274 | 0.00023274 |   0.0 |  0.00
Modify  | 1.3947     | 1.3947     | 1.3947     |   0.0 |  0.37
Other   |            | 0.1678     |            |       |  0.04

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

Total # of neighbors = 385656
Ave neighs/atom = 48.207
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 = 292.888899946696, Press = -0.0383571152734245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -36224.986     -36224.986     -36529.538     -36529.538      294.5512       294.5512       158725.71      158725.71     -272.42121     -272.42121    
     88000  -36231.21      -36231.21      -36531.978     -36531.978      290.89208      290.89208      158653.24      158653.24      378.35337      378.35337    
Loop time of 371.924 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.312 hours/ns, 2.689 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.18     | 370.18     | 370.18     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19954    | 0.19954    | 0.19954    |   0.0 |  0.05
Output  | 0.00023847 | 0.00023847 | 0.00023847 |   0.0 |  0.00
Modify  | 1.3806     | 1.3806     | 1.3806     |   0.0 |  0.37
Other   |            | 0.1664     |            |       |  0.04

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

Total # of neighbors = 385746
Ave neighs/atom = 48.21825
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 = 292.9053425764, Press = -0.144503384650604
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -36231.21      -36231.21      -36531.978     -36531.978      290.89208      290.89208      158653.24      158653.24      378.35337      378.35337    
     89000  -36226.552     -36226.552     -36532.674     -36532.674      296.06952      296.06952      158771.46      158771.46     -139.08092     -139.08092    
Loop time of 373.285 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 103.690 hours/ns, 2.679 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.52     | 371.52     | 371.52     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19992    | 0.19992    | 0.19992    |   0.0 |  0.05
Output  | 0.00023625 | 0.00023625 | 0.00023625 |   0.0 |  0.00
Modify  | 1.3979     | 1.3979     | 1.3979     |   0.0 |  0.37
Other   |            | 0.1694     |            |       |  0.05

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

Total # of neighbors = 385504
Ave neighs/atom = 48.188
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 = 292.909438316005, Press = -0.0584602585051983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -36226.552     -36226.552     -36532.674     -36532.674      296.06952      296.06952      158771.46      158771.46     -139.08092     -139.08092    
     90000  -36237.215     -36237.215     -36538.983     -36538.983      291.85942      291.85942      158607.5       158607.5       815.10923      815.10923    
Loop time of 370.381 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.65     | 368.65     | 368.65     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19849    | 0.19849    | 0.19849    |   0.0 |  0.05
Output  | 0.00027992 | 0.00027992 | 0.00027992 |   0.0 |  0.00
Modify  | 1.3698     | 1.3698     | 1.3698     |   0.0 |  0.37
Other   |            | 0.165      |            |       |  0.04

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

Total # of neighbors = 384930
Ave neighs/atom = 48.11625
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 = 292.89890907811, Press = -0.0758757196541017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -36237.215     -36237.215     -36538.983     -36538.983      291.85942      291.85942      158607.5       158607.5       815.10923      815.10923    
     91000  -36229.626     -36229.626     -36529.202     -36529.202      289.73845      289.73845      158697.5       158697.5      -26.53211      -26.53211     
Loop time of 370.863 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 103.017 hours/ns, 2.696 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.13     | 369.13     | 369.13     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19741    | 0.19741    | 0.19741    |   0.0 |  0.05
Output  | 0.00024147 | 0.00024147 | 0.00024147 |   0.0 |  0.00
Modify  | 1.3671     | 1.3671     | 1.3671     |   0.0 |  0.37
Other   |            | 0.1655     |            |       |  0.04

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

Total # of neighbors = 385256
Ave neighs/atom = 48.157
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 = 292.903295191949, Press = 0.149004977928305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -36229.626     -36229.626     -36529.202     -36529.202      289.73845      289.73845      158697.5       158697.5      -26.53211      -26.53211     
     92000  -36233.007     -36233.007     -36537.209     -36537.209      294.21207      294.21207      158796.77      158796.77     -292.82652     -292.82652    
Loop time of 378.292 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.228 ns/day, 105.081 hours/ns, 2.643 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 376.49     | 376.49     | 376.49     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20264    | 0.20264    | 0.20264    |   0.0 |  0.05
Output  | 0.00023814 | 0.00023814 | 0.00023814 |   0.0 |  0.00
Modify  | 1.4336     | 1.4336     | 1.4336     |   0.0 |  0.38
Other   |            | 0.1701     |            |       |  0.04

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

Total # of neighbors = 385550
Ave neighs/atom = 48.19375
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 = 292.9013497899, Press = -0.0737676529357954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -36233.007     -36233.007     -36537.209     -36537.209      294.21207      294.21207      158796.77      158796.77     -292.82652     -292.82652    
     93000  -36230.115     -36230.115     -36535.872     -36535.872      295.71676      295.71676      158710.18      158710.18      191.04883      191.04883    
Loop time of 370.792 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.06     | 369.06     | 369.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19613    | 0.19613    | 0.19613    |   0.0 |  0.05
Output  | 0.0015615  | 0.0015615  | 0.0015615  |   0.0 |  0.00
Modify  | 1.3722     | 1.3722     | 1.3722     |   0.0 |  0.37
Other   |            | 0.1668     |            |       |  0.04

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

Total # of neighbors = 384628
Ave neighs/atom = 48.0785
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 = 292.906404348488, Press = -0.0127443733266743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -36230.115     -36230.115     -36535.872     -36535.872      295.71676      295.71676      158710.18      158710.18      191.04883      191.04883    
     94000  -36230.886     -36230.886     -36528.366     -36528.366      287.7119       287.7119       158708.52      158708.52     -91.235093     -91.235093    
Loop time of 371.564 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.82     | 369.82     | 369.82     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19494    | 0.19494    | 0.19494    |   0.0 |  0.05
Output  | 0.00023098 | 0.00023098 | 0.00023098 |   0.0 |  0.00
Modify  | 1.3835     | 1.3835     | 1.3835     |   0.0 |  0.37
Other   |            | 0.1662     |            |       |  0.04

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

Total # of neighbors = 384888
Ave neighs/atom = 48.111
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 = 292.899340986293, Press = -0.141013173028774
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -36230.886     -36230.886     -36528.366     -36528.366      287.7119       287.7119       158708.52      158708.52     -91.235093     -91.235093    
     95000  -36224.164     -36224.164     -36528.723     -36528.723      294.55836      294.55836      158687.95      158687.95     -175.20656     -175.20656    
Loop time of 372.255 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.51     | 370.51     | 370.51     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20078    | 0.20078    | 0.20078    |   0.0 |  0.05
Output  | 0.00023463 | 0.00023463 | 0.00023463 |   0.0 |  0.00
Modify  | 1.3788     | 1.3788     | 1.3788     |   0.0 |  0.37
Other   |            | 0.1655     |            |       |  0.04

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

Total # of neighbors = 385606
Ave neighs/atom = 48.20075
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 = 292.906707302615, Press = -0.0497939042444604
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -36224.164     -36224.164     -36528.723     -36528.723      294.55836      294.55836      158687.95      158687.95     -175.20656     -175.20656    
     96000  -36228.932     -36228.932     -36534.493     -36534.493      295.52732      295.52732      158622.34      158622.34      422.58786      422.58786    
Loop time of 370.166 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.44     | 368.44     | 368.44     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19502    | 0.19502    | 0.19502    |   0.0 |  0.05
Output  | 0.00023138 | 0.00023138 | 0.00023138 |   0.0 |  0.00
Modify  | 1.3659     | 1.3659     | 1.3659     |   0.0 |  0.37
Other   |            | 0.1653     |            |       |  0.04

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

Total # of neighbors = 386194
Ave neighs/atom = 48.27425
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 = 292.901089900019, Press = 0.105443675321727
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -36228.932     -36228.932     -36534.493     -36534.493      295.52732      295.52732      158622.34      158622.34      422.58786      422.58786    
     97000  -36226.325     -36226.325     -36530.122     -36530.122      293.82082      293.82082      158611.87      158611.87      249.2635       249.2635     
Loop time of 371.276 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.55     | 369.55     | 369.55     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19544    | 0.19544    | 0.19544    |   0.0 |  0.05
Output  | 0.00023109 | 0.00023109 | 0.00023109 |   0.0 |  0.00
Modify  | 1.3676     | 1.3676     | 1.3676     |   0.0 |  0.37
Other   |            | 0.1668     |            |       |  0.04

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

Total # of neighbors = 385598
Ave neighs/atom = 48.19975
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 = 292.902585565432, Press = 0.102993650852078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -36226.325     -36226.325     -36530.122     -36530.122      293.82082      293.82082      158611.87      158611.87      249.2635       249.2635     
     98000  -36237.365     -36237.365     -36537.55      -36537.55       290.32765      290.32765      158826.3       158826.3      -538.40178     -538.40178    
Loop time of 371.911 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.309 hours/ns, 2.689 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.19     | 370.19     | 370.19     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19572    | 0.19572    | 0.19572    |   0.0 |  0.05
Output  | 0.0002313  | 0.0002313  | 0.0002313  |   0.0 |  0.00
Modify  | 1.3632     | 1.3632     | 1.3632     |   0.0 |  0.37
Other   |            | 0.1661     |            |       |  0.04

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

Total # of neighbors = 386120
Ave neighs/atom = 48.265
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 = 292.891871118691, Press = -0.108199465921171
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -36237.365     -36237.365     -36537.55      -36537.55       290.32765      290.32765      158826.3       158826.3      -538.40178     -538.40178    
     99000  -36227.551     -36227.551     -36532.543     -36532.543      294.97685      294.97685      158507.1       158507.1       926.96986      926.96986    
Loop time of 376.076 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.230 ns/day, 104.466 hours/ns, 2.659 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 374.29     | 374.29     | 374.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19976    | 0.19976    | 0.19976    |   0.0 |  0.05
Output  | 0.00023345 | 0.00023345 | 0.00023345 |   0.0 |  0.00
Modify  | 1.4146     | 1.4146     | 1.4146     |   0.0 |  0.38
Other   |            | 0.1697     |            |       |  0.05

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

Total # of neighbors = 384424
Ave neighs/atom = 48.053
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 = 292.886270065855, Press = -0.307541835891604
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -36227.551     -36227.551     -36532.543     -36532.543      294.97685      294.97685      158507.1       158507.1       926.96986      926.96986    
    100000  -36229.656     -36229.656     -36533.715     -36533.715      294.07456      294.07456      158577.73      158577.73      876.36078      876.36078    
Loop time of 376.738 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.229 ns/day, 104.650 hours/ns, 2.654 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 374.95     | 374.95     | 374.95     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20096    | 0.20096    | 0.20096    |   0.0 |  0.05
Output  | 0.00024199 | 0.00024199 | 0.00024199 |   0.0 |  0.00
Modify  | 1.4227     | 1.4227     | 1.4227     |   0.0 |  0.38
Other   |            | 0.1694     |            |       |  0.04

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

Total # of neighbors = 386474
Ave neighs/atom = 48.30925
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 = 292.884557724908, Press = 0.146124607730359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -36229.656     -36229.656     -36533.715     -36533.715      294.07456      294.07456      158577.73      158577.73      876.36078      876.36078    
    101000  -36224.659     -36224.659     -36531.196     -36531.196      296.47192      296.47192      158676.77      158676.77     -108.45974     -108.45974    
Loop time of 375.566 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.78     | 373.78     | 373.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20093    | 0.20093    | 0.20093    |   0.0 |  0.05
Output  | 0.00029586 | 0.00029586 | 0.00029586 |   0.0 |  0.00
Modify  | 1.4118     | 1.4118     | 1.4118     |   0.0 |  0.38
Other   |            | 0.1689     |            |       |  0.04

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

Total # of neighbors = 385484
Ave neighs/atom = 48.1855
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 = 292.898451644993, Press = -0.116234981337192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -36224.659     -36224.659     -36531.196     -36531.196      296.47192      296.47192      158676.77      158676.77     -108.45974     -108.45974    
    102000  -36228.976     -36228.976     -36530.998     -36530.998      292.10412      292.10412      158685.96      158685.96      84.505703      84.505703    
Loop time of 376.771 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.229 ns/day, 104.659 hours/ns, 2.654 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 374.98     | 374.98     | 374.98     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20115    | 0.20115    | 0.20115    |   0.0 |  0.05
Output  | 0.0002333  | 0.0002333  | 0.0002333  |   0.0 |  0.00
Modify  | 1.4176     | 1.4176     | 1.4176     |   0.0 |  0.38
Other   |            | 0.1712     |            |       |  0.05

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

Total # of neighbors = 386310
Ave neighs/atom = 48.28875
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 = 292.888303728199, Press = -0.292450453993162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -36228.976     -36228.976     -36530.998     -36530.998      292.10412      292.10412      158685.96      158685.96      84.505703      84.505703    
    103000  -36228.564     -36228.564     -36530.131     -36530.131      291.66456      291.66456      158500.61      158500.61      1093.5717      1093.5717    
Loop time of 372.095 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.232 ns/day, 103.360 hours/ns, 2.687 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.35     | 370.35     | 370.35     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19878    | 0.19878    | 0.19878    |   0.0 |  0.05
Output  | 0.00023061 | 0.00023061 | 0.00023061 |   0.0 |  0.00
Modify  | 1.384      | 1.384      | 1.384      |   0.0 |  0.37
Other   |            | 0.1666     |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.53     | 369.53     | 369.53     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19527    | 0.19527    | 0.19527    |   0.0 |  0.05
Output  | 0.00033975 | 0.00033975 | 0.00033975 |   0.0 |  0.00
Modify  | 1.3782     | 1.3782     | 1.3782     |   0.0 |  0.37
Other   |            | 0.1665     |            |       |  0.04

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

Total # of neighbors = 386390
Ave neighs/atom = 48.29875
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 = 292.882037963303, Press = -0.0648267078167783
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -36226.73      -36226.73      -36530.691     -36530.691      293.98036      293.98036      158695.71      158695.71      130.6437       130.6437     
    105000  -36230.244     -36230.244     -36532.586     -36532.586      292.41375      292.41375      158783.93      158783.93     -415.64513     -415.64513    
Loop time of 373.12 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.37     | 371.37     | 371.37     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19736    | 0.19736    | 0.19736    |   0.0 |  0.05
Output  | 0.00023165 | 0.00023165 | 0.00023165 |   0.0 |  0.00
Modify  | 1.3858     | 1.3858     | 1.3858     |   0.0 |  0.37
Other   |            | 0.1679     |            |       |  0.05

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

Total # of neighbors = 385660
Ave neighs/atom = 48.2075
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 = 292.887765870721, Press = -0.0428171018496932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -36230.244     -36230.244     -36532.586     -36532.586      292.41375      292.41375      158783.93      158783.93     -415.64513     -415.64513    
    106000  -36219.151     -36219.151     -36524.747     -36524.747      295.56175      295.56175      158561.81      158561.81      518.94536      518.94536    
Loop time of 375.689 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.230 ns/day, 104.358 hours/ns, 2.662 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.92     | 373.92     | 373.92     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19858    | 0.19858    | 0.19858    |   0.0 |  0.05
Output  | 0.00023388 | 0.00023388 | 0.00023388 |   0.0 |  0.00
Modify  | 1.4006     | 1.4006     | 1.4006     |   0.0 |  0.37
Other   |            | 0.1684     |            |       |  0.04

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

Total # of neighbors = 385286
Ave neighs/atom = 48.16075
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 = 292.900735592454, Press = -0.0165768062277996
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -36219.151     -36219.151     -36524.747     -36524.747      295.56175      295.56175      158561.81      158561.81      518.94536      518.94536    
    107000  -36228.265     -36228.265     -36534.608     -36534.608      296.28399      296.28399      158682.15      158682.15      140.001        140.001      
Loop time of 376.176 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.230 ns/day, 104.493 hours/ns, 2.658 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 374.41     | 374.41     | 374.41     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19921    | 0.19921    | 0.19921    |   0.0 |  0.05
Output  | 0.00028803 | 0.00028803 | 0.00028803 |   0.0 |  0.00
Modify  | 1.3979     | 1.3979     | 1.3979     |   0.0 |  0.37
Other   |            | 0.168      |            |       |  0.04

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

Total # of neighbors = 386634
Ave neighs/atom = 48.32925
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 = 292.914439429589, Press = 0.146720308482932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -36228.265     -36228.265     -36534.608     -36534.608      296.28399      296.28399      158682.15      158682.15      140.001        140.001      
    108000  -36229.879     -36229.879     -36533.034     -36533.034      293.19978      293.19978      158775.55      158775.55     -238.14261     -238.14261    
Loop time of 379.446 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.228 ns/day, 105.402 hours/ns, 2.635 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 377.63     | 377.63     | 377.63     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20387    | 0.20387    | 0.20387    |   0.0 |  0.05
Output  | 0.00023427 | 0.00023427 | 0.00023427 |   0.0 |  0.00
Modify  | 1.4366     | 1.4366     | 1.4366     |   0.0 |  0.38
Other   |            | 0.1706     |            |       |  0.04

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

Total # of neighbors = 385564
Ave neighs/atom = 48.1955
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 = 292.91474374854, Press = -0.0970026872995217
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -36229.879     -36229.879     -36533.034     -36533.034      293.19978      293.19978      158775.55      158775.55     -238.14261     -238.14261    
    109000  -36224.411     -36224.411     -36531.275     -36531.275      296.78686      296.78686      158754.46      158754.46     -151.62973     -151.62973    
Loop time of 370.174 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.45     | 368.45     | 368.45     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19458    | 0.19458    | 0.19458    |   0.0 |  0.05
Output  | 0.00031539 | 0.00031539 | 0.00031539 |   0.0 |  0.00
Modify  | 1.3607     | 1.3607     | 1.3607     |   0.0 |  0.37
Other   |            | 0.1666     |            |       |  0.05

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

Total # of neighbors = 385056
Ave neighs/atom = 48.132
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 = 292.922827654865, Press = -0.0597481958275019
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -36224.411     -36224.411     -36531.275     -36531.275      296.78686      296.78686      158754.46      158754.46     -151.62973     -151.62973    
    110000  -36230.25      -36230.25      -36534.878     -36534.878      294.62497      294.62497      158594.26      158594.26      528.80279      528.80279    
Loop time of 374.275 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.231 ns/day, 103.965 hours/ns, 2.672 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.51     | 372.51     | 372.51     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19911    | 0.19911    | 0.19911    |   0.0 |  0.05
Output  | 0.00023169 | 0.00023169 | 0.00023169 |   0.0 |  0.00
Modify  | 1.4014     | 1.4014     | 1.4014     |   0.0 |  0.37
Other   |            | 0.1676     |            |       |  0.04

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

Total # of neighbors = 385152
Ave neighs/atom = 48.144
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 = 292.92419072918, Press = -0.0982207362238593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -36230.25      -36230.25      -36534.878     -36534.878      294.62497      294.62497      158594.26      158594.26      528.80279      528.80279    
    111000  -36220.067     -36220.067     -36531.096     -36531.096      300.81572      300.81572      158674.42      158674.42      127.89526      127.89526    
Loop time of 373.88 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 372.12     | 372.12     | 372.12     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19842    | 0.19842    | 0.19842    |   0.0 |  0.05
Output  | 0.00027085 | 0.00027085 | 0.00027085 |   0.0 |  0.00
Modify  | 1.3906     | 1.3906     | 1.3906     |   0.0 |  0.37
Other   |            | 0.1675     |            |       |  0.04

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

Total # of neighbors = 385872
Ave neighs/atom = 48.234
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 = 292.932500803493, Press = 0.0437763060794202
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -36220.067     -36220.067     -36531.096     -36531.096      300.81572      300.81572      158674.42      158674.42      127.89526      127.89526    
    112000  -36229.776     -36229.776     -36530.705     -36530.705      291.0474       291.0474       158740.22      158740.22     -39.156764     -39.156764    
Loop time of 370.613 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.233 ns/day, 102.948 hours/ns, 2.698 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.88     | 368.88     | 368.88     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19716    | 0.19716    | 0.19716    |   0.0 |  0.05
Output  | 0.00028665 | 0.00028665 | 0.00028665 |   0.0 |  0.00
Modify  | 1.3714     | 1.3714     | 1.3714     |   0.0 |  0.37
Other   |            | 0.1673     |            |       |  0.05

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

Total # of neighbors = 385576
Ave neighs/atom = 48.197
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 = 292.945298844481, Press = -0.0395714333256429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -36229.776     -36229.776     -36530.705     -36530.705      291.0474       291.0474       158740.22      158740.22     -39.156764     -39.156764    
    113000  -36221.463     -36221.463     -36524.245     -36524.245      292.83924      292.83924      158647.29      158647.29     -29.59083      -29.59083     
Loop time of 371.266 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 369.52     | 369.52     | 369.52     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19746    | 0.19746    | 0.19746    |   0.0 |  0.05
Output  | 0.00023184 | 0.00023184 | 0.00023184 |   0.0 |  0.00
Modify  | 1.3793     | 1.3793     | 1.3793     |   0.0 |  0.37
Other   |            | 0.1666     |            |       |  0.04

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

Total # of neighbors = 385128
Ave neighs/atom = 48.141
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
158693.848438479

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0