# 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 3.146558970212937*${_u_distance}
variable latticeconst_converted equal 3.146558970212937*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.14655897021294
Lattice spacing in x,y,z = 3.146559 3.146559 3.146559
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (31.46559 31.46559 31.46559)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (31.46559 31.46559 31.46559)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Mo

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

kim interactions Mo
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtMo__MO_831380044253_002
pair_coeff * * Mo
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 95.94

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_831380044253_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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13533.917     -13533.917     -13620         -13620          333.15         333.15         31153.556      31153.556      2951.3963      2951.3963    
      1000  -13444.991     -13444.991     -13540.897     -13540.897      371.16625      371.16625      31332.638      31332.638     -742.81878     -742.81878    
Loop time of 124.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.693 ns/day, 34.647 hours/ns, 8.017 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    | 124.16     | 124.16     | 124.16     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10455    | 0.10455    | 0.10455    |   0.0 |  0.08
Output  | 0.00027201 | 0.00027201 | 0.00027201 |   0.0 |  0.00
Modify  | 0.39782    | 0.39782    | 0.39782    |   0.0 |  0.32
Other   |            | 0.06355    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13444.991     -13444.991     -13540.897     -13540.897      371.16625      371.16625      31332.638      31332.638     -742.81878     -742.81878    
      2000  -13444.169     -13444.169     -13528.094     -13528.094      324.79657      324.79657      31347.529      31347.529     -337.97629     -337.97629    
Loop time of 120.499 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.472 hours/ns, 8.299 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    | 119.97     | 119.97     | 119.97     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099611   | 0.099611   | 0.099611   |   0.0 |  0.08
Output  | 0.00021345 | 0.00021345 | 0.00021345 |   0.0 |  0.00
Modify  | 0.36599    | 0.36599    | 0.36599    |   0.0 |  0.30
Other   |            | 0.06068    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13444.169     -13444.169     -13528.094     -13528.094      324.79657      324.79657      31347.529      31347.529     -337.97629     -337.97629    
      3000  -13447.557     -13447.557     -13531.478     -13531.478      324.78104      324.78104      31331.627      31331.627      389.5223       389.5223     
Loop time of 124.639 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.693 ns/day, 34.622 hours/ns, 8.023 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    | 124.09     | 124.09     | 124.09     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10195    | 0.10195    | 0.10195    |   0.0 |  0.08
Output  | 0.00021107 | 0.00021107 | 0.00021107 |   0.0 |  0.00
Modify  | 0.3803     | 0.3803     | 0.3803     |   0.0 |  0.31
Other   |            | 0.06247    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13447.557     -13447.557     -13531.478     -13531.478      324.78104      324.78104      31331.627      31331.627      389.5223       389.5223     
      4000  -13442.6       -13442.6       -13536.528     -13536.528      363.51334      363.51334      31298.596      31298.596      2763.1747      2763.1747    
Loop time of 129.778 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.049 hours/ns, 7.705 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.19     | 129.19     | 129.19     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10956    | 0.10956    | 0.10956    |   0.0 |  0.08
Output  | 0.00020667 | 0.00020667 | 0.00020667 |   0.0 |  0.00
Modify  | 0.41337    | 0.41337    | 0.41337    |   0.0 |  0.32
Other   |            | 0.06655    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13442.6       -13442.6       -13536.528     -13536.528      363.51334      363.51334      31298.596      31298.596      2763.1747      2763.1747    
      5000  -13447.32      -13447.32      -13533.967     -13533.967      335.33108      335.33108      31295.136      31295.136      3087.3903      3087.3903    
Loop time of 120.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.720 ns/day, 33.356 hours/ns, 8.328 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    | 119.55     | 119.55     | 119.55     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10029    | 0.10029    | 0.10029    |   0.0 |  0.08
Output  | 0.000165   | 0.000165   | 0.000165   |   0.0 |  0.00
Modify  | 0.36957    | 0.36957    | 0.36957    |   0.0 |  0.31
Other   |            | 0.06152    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127988 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994
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 = 331.257473417924, Press = -225.197104664257
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13447.32      -13447.32      -13533.967     -13533.967      335.33108      335.33108      31295.136      31295.136      3087.3903      3087.3903    
      6000  -13442.951     -13442.951     -13527.799     -13527.799      328.37027      328.37027      31343.008      31343.008     -283.08213     -283.08213    
Loop time of 131.809 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.614 hours/ns, 7.587 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    | 131.2      | 131.2      | 131.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10772    | 0.10772    | 0.10772    |   0.0 |  0.08
Output  | 0.00020099 | 0.00020099 | 0.00020099 |   0.0 |  0.00
Modify  | 0.44033    | 0.44033    | 0.44033    |   0.0 |  0.33
Other   |            | 0.06519    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.54973626475, Press = -38.1336856798924
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13442.951     -13442.951     -13527.799     -13527.799      328.37027      328.37027      31343.008      31343.008     -283.08213     -283.08213    
      7000  -13446.343     -13446.343     -13533.061     -13533.061      335.60799      335.60799      31344.311      31344.311     -812.74809     -812.74809    
Loop time of 127.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.677 ns/day, 35.448 hours/ns, 7.836 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    | 127.02     | 127.02     | 127.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10508    | 0.10508    | 0.10508    |   0.0 |  0.08
Output  | 0.00016913 | 0.00016913 | 0.00016913 |   0.0 |  0.00
Modify  | 0.42072    | 0.42072    | 0.42072    |   0.0 |  0.33
Other   |            | 0.06394    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.602116852486, Press = -35.7100052496097
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13446.343     -13446.343     -13533.061     -13533.061      335.60799      335.60799      31344.311      31344.311     -812.74809     -812.74809    
      8000  -13442.979     -13442.979     -13532.461     -13532.461      346.30535      346.30535      31336.043      31336.043     -63.738691     -63.738691    
Loop time of 133.471 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.075 hours/ns, 7.492 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    | 132.85     | 132.85     | 132.85     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10878    | 0.10878    | 0.10878    |   0.0 |  0.08
Output  | 0.00020724 | 0.00020724 | 0.00020724 |   0.0 |  0.00
Modify  | 0.44729    | 0.44729    | 0.44729    |   0.0 |  0.34
Other   |            | 0.06631    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.554265163157, Press = -32.0894596781466
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13442.979     -13442.979     -13532.461     -13532.461      346.30535      346.30535      31336.043      31336.043     -63.738691     -63.738691    
      9000  -13444.122     -13444.122     -13533.776     -13533.776      346.97028      346.97028      31309.457      31309.457      2016.0821      2016.0821    
Loop time of 123.86 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.698 ns/day, 34.406 hours/ns, 8.074 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    | 123.29     | 123.29     | 123.29     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10247    | 0.10247    | 0.10247    |   0.0 |  0.08
Output  | 0.00017    | 0.00017    | 0.00017    |   0.0 |  0.00
Modify  | 0.40433    | 0.40433    | 0.40433    |   0.0 |  0.33
Other   |            | 0.06244    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.934082864195, Press = -22.5793080842441
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13444.122     -13444.122     -13533.776     -13533.776      346.97028      346.97028      31309.457      31309.457      2016.0821      2016.0821    
     10000  -13449.971     -13449.971     -13536.432     -13536.432      334.6114       334.6114       31277.91       31277.91       4191.5862      4191.5862    
Loop time of 115.674 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.132 hours/ns, 8.645 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.15     | 115.15     | 115.15     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096487   | 0.096487   | 0.096487   |   0.0 |  0.08
Output  | 0.00017253 | 0.00017253 | 0.00017253 |   0.0 |  0.00
Modify  | 0.36551    | 0.36551    | 0.36551    |   0.0 |  0.32
Other   |            | 0.05856    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.27651249787, Press = 5.08114978858008
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13449.971     -13449.971     -13536.432     -13536.432      334.6114       334.6114       31277.91       31277.91       4191.5862      4191.5862    
     11000  -13443.974     -13443.974     -13531.875     -13531.875      340.18898      340.18898      31365.876      31365.876     -2619.9953     -2619.9953    
Loop time of 121.727 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.813 hours/ns, 8.215 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    | 121.17     | 121.17     | 121.17     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10097    | 0.10097    | 0.10097    |   0.0 |  0.08
Output  | 0.00016462 | 0.00016462 | 0.00016462 |   0.0 |  0.00
Modify  | 0.39624    | 0.39624    | 0.39624    |   0.0 |  0.33
Other   |            | 0.06191    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.982112788875, Press = 3.30448950129016
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13443.974     -13443.974     -13531.875     -13531.875      340.18898      340.18898      31365.876      31365.876     -2619.9953     -2619.9953    
     12000  -13447.22      -13447.22      -13531.995     -13531.995      328.08623      328.08623      31356.37       31356.37      -1843.4798     -1843.4798    
Loop time of 122.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.706 ns/day, 33.986 hours/ns, 8.173 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    | 121.79     | 121.79     | 121.79     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10135    | 0.10135    | 0.10135    |   0.0 |  0.08
Output  | 0.00021215 | 0.00021215 | 0.00021215 |   0.0 |  0.00
Modify  | 0.398      | 0.398      | 0.398      |   0.0 |  0.33
Other   |            | 0.06151    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.69240211092, Press = -10.103083547465
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13447.22      -13447.22      -13531.995     -13531.995      328.08623      328.08623      31356.37       31356.37      -1843.4798     -1843.4798    
     13000  -13447.615     -13447.615     -13532.661     -13532.661      329.13855      329.13855      31335.017      31335.017     -302.16085     -302.16085    
Loop time of 125.809 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.687 ns/day, 34.947 hours/ns, 7.949 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    | 125.23     | 125.23     | 125.23     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10353    | 0.10353    | 0.10353    |   0.0 |  0.08
Output  | 0.00016808 | 0.00016808 | 0.00016808 |   0.0 |  0.00
Modify  | 0.41646    | 0.41646    | 0.41646    |   0.0 |  0.33
Other   |            | 0.06329    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.769345861816, Press = -10.7776001861456
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13447.615     -13447.615     -13532.661     -13532.661      329.13855      329.13855      31335.017      31335.017     -302.16085     -302.16085    
     14000  -13440.852     -13440.852     -13528.173     -13528.173      337.94021      337.94021      31319.871      31319.871      1777.1734      1777.1734    
Loop time of 118.838 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.010 hours/ns, 8.415 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    | 118.3      | 118.3      | 118.3      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098063   | 0.098063   | 0.098063   |   0.0 |  0.08
Output  | 0.00023282 | 0.00023282 | 0.00023282 |   0.0 |  0.00
Modify  | 0.38017    | 0.38017    | 0.38017    |   0.0 |  0.32
Other   |            | 0.05943    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.13251609064, Press = -8.33874490136841
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13440.852     -13440.852     -13528.173     -13528.173      337.94021      337.94021      31319.871      31319.871      1777.1734      1777.1734    
     15000  -13445.159     -13445.159     -13532.3       -13532.3        337.24486      337.24486      31306.023      31306.023      2376.4435      2376.4435    
Loop time of 124.017 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.449 hours/ns, 8.063 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    | 123.45     | 123.45     | 123.45     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10142    | 0.10142    | 0.10142    |   0.0 |  0.08
Output  | 0.00025835 | 0.00025835 | 0.00025835 |   0.0 |  0.00
Modify  | 0.40213    | 0.40213    | 0.40213    |   0.0 |  0.32
Other   |            | 0.06211    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.215597922268, Press = -1.56149716129883
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13445.159     -13445.159     -13532.3       -13532.3        337.24486      337.24486      31306.023      31306.023      2376.4435      2376.4435    
     16000  -13446.879     -13446.879     -13532.455     -13532.455      331.18889      331.18889      31357.956      31357.956     -1973.0825     -1973.0825    
Loop time of 116.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.741 ns/day, 32.372 hours/ns, 8.581 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    | 116.01     | 116.01     | 116.01     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09776    | 0.09776    | 0.09776    |   0.0 |  0.08
Output  | 0.00016921 | 0.00016921 | 0.00016921 |   0.0 |  0.00
Modify  | 0.37185    | 0.37185    | 0.37185    |   0.0 |  0.32
Other   |            | 0.05861    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127988 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.205043515048, Press = 0.307314366979047
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13446.879     -13446.879     -13532.455     -13532.455      331.18889      331.18889      31357.956      31357.956     -1973.0825     -1973.0825    
     17000  -13443.497     -13443.497     -13529.319     -13529.319      332.14066      332.14066      31371.987      31371.987     -2806.5995     -2806.5995    
Loop time of 118.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.729 ns/day, 32.936 hours/ns, 8.434 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    | 118.03     | 118.03     | 118.03     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098073   | 0.098073   | 0.098073   |   0.0 |  0.08
Output  | 0.00017099 | 0.00017099 | 0.00017099 |   0.0 |  0.00
Modify  | 0.37832    | 0.37832    | 0.37832    |   0.0 |  0.32
Other   |            | 0.05929    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.943104813547, Press = -6.04784548989421
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13443.497     -13443.497     -13529.319     -13529.319      332.14066      332.14066      31371.987      31371.987     -2806.5995     -2806.5995    
     18000  -13446.673     -13446.673     -13533.166     -13533.166      334.73643      334.73643      31337.98       31337.98      -502.21131     -502.21131    
Loop time of 117.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.734 ns/day, 32.703 hours/ns, 8.494 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    | 117.2      | 117.2      | 117.2      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098628   | 0.098628   | 0.098628   |   0.0 |  0.08
Output  | 0.00016682 | 0.00016682 | 0.00016682 |   0.0 |  0.00
Modify  | 0.37633    | 0.37633    | 0.37633    |   0.0 |  0.32
Other   |            | 0.0597     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.986664468938, Press = -6.28221754671925
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13446.673     -13446.673     -13533.166     -13533.166      334.73643      334.73643      31337.98       31337.98      -502.21131     -502.21131    
     19000  -13443.574     -13443.574     -13531.47      -13531.47       340.16632      340.16632      31328.728      31328.728      748.76567      748.76567    
Loop time of 114.542 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.817 hours/ns, 8.730 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.03     | 114.03     | 114.03     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095963   | 0.095963   | 0.095963   |   0.0 |  0.08
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.3618     | 0.3618     | 0.3618     |   0.0 |  0.32
Other   |            | 0.05899    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.172264285692, Press = -4.27205423177808
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13443.574     -13443.574     -13531.47      -13531.47       340.16632      340.16632      31328.728      31328.728      748.76567      748.76567    
     20000  -13446.02      -13446.02      -13531.663     -13531.663      331.44814      331.44814      31323.688      31323.688      999.06737      999.06737    
Loop time of 114.365 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.768 hours/ns, 8.744 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.85     | 113.85     | 113.85     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095754   | 0.095754   | 0.095754   |   0.0 |  0.08
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.36067    | 0.36067    | 0.36067    |   0.0 |  0.32
Other   |            | 0.05856    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.364369765066, Press = -2.28310128947124
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13446.02      -13446.02      -13531.663     -13531.663      331.44814      331.44814      31323.688      31323.688      999.06737      999.06737    
     21000  -13443.715     -13443.715     -13529.759     -13529.759      332.99938      332.99938      31355.185      31355.185     -1479.6914     -1479.6914    
Loop time of 118.381 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.730 ns/day, 32.884 hours/ns, 8.447 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    | 117.85     | 117.85     | 117.85     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098369   | 0.098369   | 0.098369   |   0.0 |  0.08
Output  | 0.00016607 | 0.00016607 | 0.00016607 |   0.0 |  0.00
Modify  | 0.37824    | 0.37824    | 0.37824    |   0.0 |  0.32
Other   |            | 0.05882    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.375755704151, Press = -1.75326483458736
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13443.715     -13443.715     -13529.759     -13529.759      332.99938      332.99938      31355.185      31355.185     -1479.6914     -1479.6914    
     22000  -13446.817     -13446.817     -13532.317     -13532.317      330.89287      330.89287      31366.507      31366.507     -2774.1458     -2774.1458    
Loop time of 122.216 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.707 ns/day, 33.949 hours/ns, 8.182 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    | 121.66     | 121.66     | 121.66     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10189    | 0.10189    | 0.10189    |   0.0 |  0.08
Output  | 0.00024538 | 0.00024538 | 0.00024538 |   0.0 |  0.00
Modify  | 0.39652    | 0.39652    | 0.39652    |   0.0 |  0.32
Other   |            | 0.06103    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.1779242479, Press = -5.6258714250461
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13446.817     -13446.817     -13532.317     -13532.317      330.89287      330.89287      31366.507      31366.507     -2774.1458     -2774.1458    
     23000  -13446.753     -13446.753     -13534.782     -13534.782      340.68049      340.68049      31329.448      31329.448      180.59856      180.59856    
Loop time of 133.246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.013 hours/ns, 7.505 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    | 132.62     | 132.62     | 132.62     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10865    | 0.10865    | 0.10865    |   0.0 |  0.08
Output  | 0.00021172 | 0.00021172 | 0.00021172 |   0.0 |  0.00
Modify  | 0.44969    | 0.44969    | 0.44969    |   0.0 |  0.34
Other   |            | 0.06705    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.099017545195, Press = -6.74999514438709
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13446.753     -13446.753     -13534.782     -13534.782      340.68049      340.68049      31329.448      31329.448      180.59856      180.59856    
     24000  -13443.46      -13443.46      -13530.349     -13530.349      336.27138      336.27138      31299.332      31299.332      3337.9333      3337.9333    
Loop time of 133.215 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 37.004 hours/ns, 7.507 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    | 132.59     | 132.59     | 132.59     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10859    | 0.10859    | 0.10859    |   0.0 |  0.08
Output  | 0.00020741 | 0.00020741 | 0.00020741 |   0.0 |  0.00
Modify  | 0.45107    | 0.45107    | 0.45107    |   0.0 |  0.34
Other   |            | 0.06626    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.961293938166, Press = -3.22311007294322
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13443.46      -13443.46      -13530.349     -13530.349      336.27138      336.27138      31299.332      31299.332      3337.9333      3337.9333    
     25000  -13446.054     -13446.054     -13532.278     -13532.278      333.69309      333.69309      31315.382      31315.382      1669.608       1669.608     
Loop time of 132.957 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.933 hours/ns, 7.521 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    | 132.34     | 132.34     | 132.34     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10907    | 0.10907    | 0.10907    |   0.0 |  0.08
Output  | 0.00021849 | 0.00021849 | 0.00021849 |   0.0 |  0.00
Modify  | 0.44535    | 0.44535    | 0.44535    |   0.0 |  0.33
Other   |            | 0.06592    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.934415852981, Press = -0.283629052441415
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13446.054     -13446.054     -13532.278     -13532.278      333.69309      333.69309      31315.382      31315.382      1669.608       1669.608     
     26000  -13444.751     -13444.751     -13531.526     -13531.526      335.82691      335.82691      31354.621      31354.621     -1569.501      -1569.501     
Loop time of 133.619 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.116 hours/ns, 7.484 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    | 132.99     | 132.99     | 132.99     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11141    | 0.11141    | 0.11141    |   0.0 |  0.08
Output  | 0.00020928 | 0.00020928 | 0.00020928 |   0.0 |  0.00
Modify  | 0.45015    | 0.45015    | 0.45015    |   0.0 |  0.34
Other   |            | 0.06637    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.07597357861, Press = -1.65690013262014
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13444.751     -13444.751     -13531.526     -13531.526      335.82691      335.82691      31354.621      31354.621     -1569.501      -1569.501     
     27000  -13443.423     -13443.423     -13529.864     -13529.864      334.53395      334.53395      31351.259      31351.259     -998.02369     -998.02369    
Loop time of 133.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 37.005 hours/ns, 7.506 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.59     | 132.59     | 132.59     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10857    | 0.10857    | 0.10857    |   0.0 |  0.08
Output  | 0.00017037 | 0.00017037 | 0.00017037 |   0.0 |  0.00
Modify  | 0.44891    | 0.44891    | 0.44891    |   0.0 |  0.34
Other   |            | 0.06613    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.101329534149, Press = -3.81658960724896
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13443.423     -13443.423     -13529.864     -13529.864      334.53395      334.53395      31351.259      31351.259     -998.02369     -998.02369    
     28000  -13447.429     -13447.429     -13533.764     -13533.764      334.12599      334.12599      31331.435      31331.435      124.67815      124.67815    
Loop time of 133.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.087 hours/ns, 7.490 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.89     | 132.89     | 132.89     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10851    | 0.10851    | 0.10851    |   0.0 |  0.08
Output  | 0.00016991 | 0.00016991 | 0.00016991 |   0.0 |  0.00
Modify  | 0.44879    | 0.44879    | 0.44879    |   0.0 |  0.34
Other   |            | 0.06654    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.981280408884, Press = -3.26005430112024
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13447.429     -13447.429     -13533.764     -13533.764      334.12599      334.12599      31331.435      31331.435      124.67815      124.67815    
     29000  -13445.523     -13445.523     -13530.152     -13530.152      327.52506      327.52506      31328.372      31328.372      682.73112      682.73112    
Loop time of 122.456 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.706 ns/day, 34.015 hours/ns, 8.166 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    | 121.9      | 121.9      | 121.9      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10048    | 0.10048    | 0.10048    |   0.0 |  0.08
Output  | 0.00016847 | 0.00016847 | 0.00016847 |   0.0 |  0.00
Modify  | 0.39489    | 0.39489    | 0.39489    |   0.0 |  0.32
Other   |            | 0.06084    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.934924841202, Press = -2.54814269234587
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13445.523     -13445.523     -13530.152     -13530.152      327.52506      327.52506      31328.372      31328.372      682.73112      682.73112    
     30000  -13444.681     -13444.681     -13528.846     -13528.846      325.72614      325.72614      31329.345      31329.345      906.12806      906.12806    
Loop time of 115.075 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.965 hours/ns, 8.690 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.56     | 114.56     | 114.56     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098943   | 0.098943   | 0.098943   |   0.0 |  0.09
Output  | 0.00016839 | 0.00016839 | 0.00016839 |   0.0 |  0.00
Modify  | 0.36346    | 0.36346    | 0.36346    |   0.0 |  0.32
Other   |            | 0.05599    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.920383033246, Press = -2.25286287127569
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13444.681     -13444.681     -13528.846     -13528.846      325.72614      325.72614      31329.345      31329.345      906.12806      906.12806    
     31000  -13444.851     -13444.851     -13531.456     -13531.456      335.16887      335.16887      31334.692      31334.692      180.37934      180.37934    
Loop time of 118.237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.844 hours/ns, 8.458 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    | 117.7      | 117.7      | 117.7      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10037    | 0.10037    | 0.10037    |   0.0 |  0.08
Output  | 0.0002291  | 0.0002291  | 0.0002291  |   0.0 |  0.00
Modify  | 0.38049    | 0.38049    | 0.38049    |   0.0 |  0.32
Other   |            | 0.05835    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.000963914046, Press = -2.78967288577531
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13444.851     -13444.851     -13531.456     -13531.456      335.16887      335.16887      31334.692      31334.692      180.37934      180.37934    
     32000  -13444.61      -13444.61      -13531.327     -13531.327      335.60264      335.60264      31333.687      31333.687      178.97705      178.97705    
Loop time of 133.044 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.957 hours/ns, 7.516 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.43     | 132.43     | 132.43     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10787    | 0.10787    | 0.10787    |   0.0 |  0.08
Output  | 0.0001669  | 0.0001669  | 0.0001669  |   0.0 |  0.00
Modify  | 0.44498    | 0.44498    | 0.44498    |   0.0 |  0.33
Other   |            | 0.06556    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.006069786244, Press = -2.52285227914339
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13444.61      -13444.61      -13531.327     -13531.327      335.60264      335.60264      31333.687      31333.687      178.97705      178.97705    
     33000  -13447.255     -13447.255     -13531.466     -13531.466      325.9043       325.9043       31332.277      31332.277      143.77993      143.77993    
Loop time of 129.912 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.087 hours/ns, 7.698 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.31     | 129.31     | 129.31     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10676    | 0.10676    | 0.10676    |   0.0 |  0.08
Output  | 0.00016847 | 0.00016847 | 0.00016847 |   0.0 |  0.00
Modify  | 0.43418    | 0.43418    | 0.43418    |   0.0 |  0.33
Other   |            | 0.06479    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.023792668862, Press = -2.7479198550948
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13447.255     -13447.255     -13531.466     -13531.466      325.9043       325.9043       31332.277      31332.277      143.77993      143.77993    
     34000  -13443.781     -13443.781     -13530.424     -13530.424      335.31741      335.31741      31330.762      31330.762      619.86903      619.86903    
Loop time of 132.567 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.824 hours/ns, 7.543 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    | 131.95     | 131.95     | 131.95     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10695    | 0.10695    | 0.10695    |   0.0 |  0.08
Output  | 0.00016607 | 0.00016607 | 0.00016607 |   0.0 |  0.00
Modify  | 0.44161    | 0.44161    | 0.44161    |   0.0 |  0.33
Other   |            | 0.06512    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.921853562115, Press = -2.46899544705992
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13443.781     -13443.781     -13530.424     -13530.424      335.31741      335.31741      31330.762      31330.762      619.86903      619.86903    
     35000  -13447.285     -13447.285     -13531.796     -13531.796      327.06468      327.06468      31331.64       31331.64       63.657094      63.657094    
Loop time of 133.403 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.056 hours/ns, 7.496 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    | 132.78     | 132.78     | 132.78     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1081     | 0.1081     | 0.1081     |   0.0 |  0.08
Output  | 0.00016976 | 0.00016976 | 0.00016976 |   0.0 |  0.00
Modify  | 0.44629    | 0.44629    | 0.44629    |   0.0 |  0.33
Other   |            | 0.0652     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.872548311048, Press = -1.759061814335
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13447.285     -13447.285     -13531.796     -13531.796      327.06468      327.06468      31331.64       31331.64       63.657094      63.657094    
     36000  -13444.481     -13444.481     -13530.396     -13530.396      332.4977       332.4977       31350.822      31350.822     -1236.7165     -1236.7165    
Loop time of 124.485 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.579 hours/ns, 8.033 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    | 123.91     | 123.91     | 123.91     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10342    | 0.10342    | 0.10342    |   0.0 |  0.08
Output  | 0.00016862 | 0.00016862 | 0.00016862 |   0.0 |  0.00
Modify  | 0.40794    | 0.40794    | 0.40794    |   0.0 |  0.33
Other   |            | 0.06169    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.876237978335, Press = -2.18380027229583
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13444.481     -13444.481     -13530.396     -13530.396      332.4977       332.4977       31350.822      31350.822     -1236.7165     -1236.7165    
     37000  -13446.652     -13446.652     -13532.847     -13532.847      333.58304      333.58304      31353.145      31353.145     -1762.2325     -1762.2325    
Loop time of 126.595 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.165 hours/ns, 7.899 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    | 126.01     | 126.01     | 126.01     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10446    | 0.10446    | 0.10446    |   0.0 |  0.08
Output  | 0.00022893 | 0.00022893 | 0.00022893 |   0.0 |  0.00
Modify  | 0.41718    | 0.41718    | 0.41718    |   0.0 |  0.33
Other   |            | 0.06281    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.94147483746, Press = -3.5831652024121
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13446.652     -13446.652     -13532.847     -13532.847      333.58304      333.58304      31353.145      31353.145     -1762.2325     -1762.2325    
     38000  -13445.704     -13445.704     -13532.585     -13532.585      336.23977      336.23977      31318.833      31318.833      1419.3601      1419.3601    
Loop time of 120.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.720 ns/day, 33.336 hours/ns, 8.333 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    | 119.46     | 119.46     | 119.46     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099622   | 0.099622   | 0.099622   |   0.0 |  0.08
Output  | 0.00047625 | 0.00047625 | 0.00047625 |   0.0 |  0.00
Modify  | 0.38796    | 0.38796    | 0.38796    |   0.0 |  0.32
Other   |            | 0.06082    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.046033722237, Press = -3.89925013306212
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13445.704     -13445.704     -13532.585     -13532.585      336.23977      336.23977      31318.833      31318.833      1419.3601      1419.3601    
     39000  -13443.498     -13443.498     -13530.753     -13530.753      337.68331      337.68331      31290.551      31290.551      3927.6047      3927.6047    
Loop time of 122.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.707 ns/day, 33.961 hours/ns, 8.179 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    | 121.7      | 121.7      | 121.7      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10104    | 0.10104    | 0.10104    |   0.0 |  0.08
Output  | 0.00020894 | 0.00020894 | 0.00020894 |   0.0 |  0.00
Modify  | 0.3979     | 0.3979     | 0.3979     |   0.0 |  0.33
Other   |            | 0.0611     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.05214907467, Press = -1.87023621537089
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13443.498     -13443.498     -13530.753     -13530.753      337.68331      337.68331      31290.551      31290.551      3927.6047      3927.6047    
     40000  -13447.115     -13447.115     -13533.294     -13533.294      333.52296      333.52296      31326.819      31326.819      320.17964      320.17964    
Loop time of 124.377 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.549 hours/ns, 8.040 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    | 123.8      | 123.8      | 123.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10247    | 0.10247    | 0.10247    |   0.0 |  0.08
Output  | 0.00017013 | 0.00017013 | 0.00017013 |   0.0 |  0.00
Modify  | 0.40861    | 0.40861    | 0.40861    |   0.0 |  0.33
Other   |            | 0.06202    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.075849535561, Press = -0.957522049241741
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13447.115     -13447.115     -13533.294     -13533.294      333.52296      333.52296      31326.819      31326.819      320.17964      320.17964    
     41000  -13442.907     -13442.907     -13529.893     -13529.893      336.64481      336.64481      31352.211      31352.211     -1074.0205     -1074.0205    
Loop time of 117.52 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.735 ns/day, 32.644 hours/ns, 8.509 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    | 116.99     | 116.99     | 116.99     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10171    | 0.10171    | 0.10171    |   0.0 |  0.09
Output  | 0.00016909 | 0.00016909 | 0.00016909 |   0.0 |  0.00
Modify  | 0.375      | 0.375      | 0.375      |   0.0 |  0.32
Other   |            | 0.05717    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.098800584495, Press = -1.67180629800161
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13442.907     -13442.907     -13529.893     -13529.893      336.64481      336.64481      31352.211      31352.211     -1074.0205     -1074.0205    
     42000  -13444.442     -13444.442     -13531.37      -13531.37       336.41804      336.41804      31351.315      31351.315     -1213.8136     -1213.8136    
Loop time of 128.231 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.620 hours/ns, 7.798 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.64     | 127.64     | 127.64     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10499    | 0.10499    | 0.10499    |   0.0 |  0.08
Output  | 0.00016775 | 0.00016775 | 0.00016775 |   0.0 |  0.00
Modify  | 0.42232    | 0.42232    | 0.42232    |   0.0 |  0.33
Other   |            | 0.06364    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127964 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.048790220061, Press = -2.56823051813283
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13444.442     -13444.442     -13531.37      -13531.37       336.41804      336.41804      31351.315      31351.315     -1213.8136     -1213.8136    
     43000  -13445.582     -13445.582     -13531.661     -13531.661      333.13356      333.13356      31322.254      31322.254      967.00167      967.00167    
Loop time of 128.272 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.631 hours/ns, 7.796 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    | 127.68     | 127.68     | 127.68     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10582    | 0.10582    | 0.10582    |   0.0 |  0.08
Output  | 0.00020996 | 0.00020996 | 0.00020996 |   0.0 |  0.00
Modify  | 0.42682    | 0.42682    | 0.42682    |   0.0 |  0.33
Other   |            | 0.06389    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127964 ave      127964 max      127964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127964
Ave neighs/atom = 63.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.020364485454, Press = -2.68813414339265
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13445.582     -13445.582     -13531.661     -13531.661      333.13356      333.13356      31322.254      31322.254      967.00167      967.00167    
     44000  -13446.669     -13446.669     -13532.663     -13532.663      332.80445      332.80445      31295.748      31295.748      3106.4102      3106.4102    
Loop time of 133.553 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.098 hours/ns, 7.488 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    | 132.93     | 132.93     | 132.93     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10909    | 0.10909    | 0.10909    |   0.0 |  0.08
Output  | 0.00025804 | 0.00025804 | 0.00025804 |   0.0 |  0.00
Modify  | 0.44732    | 0.44732    | 0.44732    |   0.0 |  0.33
Other   |            | 0.0663     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.948351980121, Press = -1.38098997747124
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13446.669     -13446.669     -13532.663     -13532.663      332.80445      332.80445      31295.748      31295.748      3106.4102      3106.4102    
     45000  -13446.275     -13446.275     -13530.885     -13530.885      327.44688      327.44688      31331.102      31331.102      519.33549      519.33549    
Loop time of 132.879 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.911 hours/ns, 7.526 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    | 132.26     | 132.26     | 132.26     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10919    | 0.10919    | 0.10919    |   0.0 |  0.08
Output  | 0.000167   | 0.000167   | 0.000167   |   0.0 |  0.00
Modify  | 0.44568    | 0.44568    | 0.44568    |   0.0 |  0.34
Other   |            | 0.06492    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.939278152392, Press = -0.0281251224204708
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13446.275     -13446.275     -13530.885     -13530.885      327.44688      327.44688      31331.102      31331.102      519.33549      519.33549    
     46000  -13444.989     -13444.989     -13531.746     -13531.746      335.75621      335.75621      31377.354      31377.354     -3620.5766     -3620.5766    
Loop time of 133.675 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.132 hours/ns, 7.481 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    | 133.05     | 133.05     | 133.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10906    | 0.10906    | 0.10906    |   0.0 |  0.08
Output  | 0.00021048 | 0.00021048 | 0.00021048 |   0.0 |  0.00
Modify  | 0.44764    | 0.44764    | 0.44764    |   0.0 |  0.33
Other   |            | 0.06495    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.865492144846, Press = -1.32450187733321
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13444.989     -13444.989     -13531.746     -13531.746      335.75621      335.75621      31377.354      31377.354     -3620.5766     -3620.5766    
     47000  -13447.047     -13447.047     -13533.363     -13533.363      334.05003      334.05003      31358.472      31358.472     -2215.2784     -2215.2784    
Loop time of 131.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.638 hours/ns, 7.582 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    | 131.28     | 131.28     | 131.28     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10809    | 0.10809    | 0.10809    |   0.0 |  0.08
Output  | 0.00017057 | 0.00017057 | 0.00017057 |   0.0 |  0.00
Modify  | 0.44505    | 0.44505    | 0.44505    |   0.0 |  0.34
Other   |            | 0.06543    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.871693564787, Press = -2.59936051549665
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13447.047     -13447.047     -13533.363     -13533.363      334.05003      334.05003      31358.472      31358.472     -2215.2784     -2215.2784    
     48000  -13442.2       -13442.2       -13529.355     -13529.355      337.29735      337.29735      31324.838      31324.838      1338.3148      1338.3148    
Loop time of 127.705 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.677 ns/day, 35.474 hours/ns, 7.831 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    | 127.12     | 127.12     | 127.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10552    | 0.10552    | 0.10552    |   0.0 |  0.08
Output  | 0.00016834 | 0.00016834 | 0.00016834 |   0.0 |  0.00
Modify  | 0.42004    | 0.42004    | 0.42004    |   0.0 |  0.33
Other   |            | 0.0626     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127966 ave      127966 max      127966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127966
Ave neighs/atom = 63.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.921356729084, Press = -2.3796618333436
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13442.2       -13442.2       -13529.355     -13529.355      337.29735      337.29735      31324.838      31324.838      1338.3148      1338.3148    
     49000  -13446.54      -13446.54      -13530.559     -13530.559      325.16552      325.16552      31305.047      31305.047      2639.4331      2639.4331    
Loop time of 131.669 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.575 hours/ns, 7.595 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.05     | 131.05     | 131.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11475    | 0.11475    | 0.11475    |   0.0 |  0.09
Output  | 0.00022529 | 0.00022529 | 0.00022529 |   0.0 |  0.00
Modify  | 0.44541    | 0.44541    | 0.44541    |   0.0 |  0.34
Other   |            | 0.06247    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.978002435904, Press = -1.22040878117151
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13446.54      -13446.54      -13530.559     -13530.559      325.16552      325.16552      31305.047      31305.047      2639.4331      2639.4331    
     50000  -13443.38      -13443.38      -13531.757     -13531.757      342.02835      342.02835      31343.083      31343.083     -515.47328     -515.47328    
Loop time of 132.118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.700 hours/ns, 7.569 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.51     | 131.51     | 131.51     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10766    | 0.10766    | 0.10766    |   0.0 |  0.08
Output  | 0.0002128  | 0.0002128  | 0.0002128  |   0.0 |  0.00
Modify  | 0.43998    | 0.43998    | 0.43998    |   0.0 |  0.33
Other   |            | 0.06534    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.943778374915, Press = 1.25897220576421
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13443.38      -13443.38      -13531.757     -13531.757      342.02835      342.02835      31343.083      31343.083     -515.47328     -515.47328    
     51000  -13448.432     -13448.432     -13532.637     -13532.637      325.88294      325.88294      31366.354      31366.354     -2802.1891     -2802.1891    
Loop time of 132.929 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.925 hours/ns, 7.523 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.31     | 132.31     | 132.31     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10795    | 0.10795    | 0.10795    |   0.0 |  0.08
Output  | 0.00021334 | 0.00021334 | 0.00021334 |   0.0 |  0.00
Modify  | 0.44621    | 0.44621    | 0.44621    |   0.0 |  0.34
Other   |            | 0.06597    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.900630842106, Press = -1.16488904280851
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13448.432     -13448.432     -13532.637     -13532.637      325.88294      325.88294      31366.354      31366.354     -2802.1891     -2802.1891    
     52000  -13444.211     -13444.211     -13529.045     -13529.045      328.31794      328.31794      31347.385      31347.385     -807.88941     -807.88941    
Loop time of 126.22 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.685 ns/day, 35.061 hours/ns, 7.923 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    | 125.63     | 125.63     | 125.63     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.104      | 0.104      | 0.104      |   0.0 |  0.08
Output  | 0.0001668  | 0.0001668  | 0.0001668  |   0.0 |  0.00
Modify  | 0.41947    | 0.41947    | 0.41947    |   0.0 |  0.33
Other   |            | 0.06397    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.844971194587, Press = -2.28656600293763
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13444.211     -13444.211     -13529.045     -13529.045      328.31794      328.31794      31347.385      31347.385     -807.88941     -807.88941    
     53000  -13449.437     -13449.437     -13534.612     -13534.612      329.6331       329.6331       31312.056      31312.056      1555.8494      1555.8494    
Loop time of 114.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.791 hours/ns, 8.738 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.93     | 113.93     | 113.93     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094944   | 0.094944   | 0.094944   |   0.0 |  0.08
Output  | 0.00026485 | 0.00026485 | 0.00026485 |   0.0 |  0.00
Modify  | 0.36119    | 0.36119    | 0.36119    |   0.0 |  0.32
Other   |            | 0.05902    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.819442319591, Press = -1.86091762676872
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13449.437     -13449.437     -13534.612     -13534.612      329.6331       329.6331       31312.056      31312.056      1555.8494      1555.8494    
     54000  -13444.955     -13444.955     -13531.324     -13531.324      334.25532      334.25532      31310.81       31310.81       2129.9179      2129.9179    
Loop time of 134.464 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.351 hours/ns, 7.437 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.84     | 133.84     | 133.84     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11364    | 0.11364    | 0.11364    |   0.0 |  0.08
Output  | 0.00016978 | 0.00016978 | 0.00016978 |   0.0 |  0.00
Modify  | 0.44523    | 0.44523    | 0.44523    |   0.0 |  0.33
Other   |            | 0.06464    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.780250442124, Press = -0.941069065873189
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13444.955     -13444.955     -13531.324     -13531.324      334.25532      334.25532      31310.81       31310.81       2129.9179      2129.9179    
     55000  -13447.675     -13447.675     -13533.758     -13533.758      333.15037      333.15037      31342.457      31342.457     -957.72076     -957.72076    
Loop time of 134.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.301 hours/ns, 7.447 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.66     | 133.66     | 133.66     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11323    | 0.11323    | 0.11323    |   0.0 |  0.08
Output  | 0.00017372 | 0.00017372 | 0.00017372 |   0.0 |  0.00
Modify  | 0.4452     | 0.4452     | 0.4452     |   0.0 |  0.33
Other   |            | 0.06505    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.762383242041, Press = 0.00537967891160495
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13447.675     -13447.675     -13533.758     -13533.758      333.15037      333.15037      31342.457      31342.457     -957.72076     -957.72076    
     56000  -13446.457     -13446.457     -13530.544     -13530.544      325.42562      325.42562      31397.314      31397.314     -5109.6323     -5109.6323    
Loop time of 128.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.581 hours/ns, 7.807 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    | 127.5      | 127.5      | 127.5      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10593    | 0.10593    | 0.10593    |   0.0 |  0.08
Output  | 0.00029924 | 0.00029924 | 0.00029924 |   0.0 |  0.00
Modify  | 0.42174    | 0.42174    | 0.42174    |   0.0 |  0.33
Other   |            | 0.06295    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.753395768225, Press = -1.45680227788551
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13446.457     -13446.457     -13530.544     -13530.544      325.42562      325.42562      31397.314      31397.314     -5109.6323     -5109.6323    
     57000  -13447.978     -13447.978     -13531.603     -13531.603      323.63717      323.63717      31338.7        31338.7       -373.2005      -373.2005     
Loop time of 126.375 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.104 hours/ns, 7.913 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    | 125.79     | 125.79     | 125.79     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10819    | 0.10819    | 0.10819    |   0.0 |  0.09
Output  | 0.00017582 | 0.00017582 | 0.00017582 |   0.0 |  0.00
Modify  | 0.41979    | 0.41979    | 0.41979    |   0.0 |  0.33
Other   |            | 0.06186    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.699230832332, Press = -2.10213765209512
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13447.978     -13447.978     -13531.603     -13531.603      323.63717      323.63717      31338.7        31338.7       -373.2005      -373.2005     
     58000  -13447.196     -13447.196     -13531.17      -13531.17       324.98947      324.98947      31313.089      31313.089      1817.3904      1817.3904    
Loop time of 133.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.953 hours/ns, 7.517 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.4      | 132.4      | 132.4      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1099     | 0.1099     | 0.1099     |   0.0 |  0.08
Output  | 0.00021097 | 0.00021097 | 0.00021097 |   0.0 |  0.00
Modify  | 0.45005    | 0.45005    | 0.45005    |   0.0 |  0.34
Other   |            | 0.06723    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.706041904813, Press = -1.59182442945246
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13447.196     -13447.196     -13531.17      -13531.17       324.98947      324.98947      31313.089      31313.089      1817.3904      1817.3904    
     59000  -13448.192     -13448.192     -13533.02      -13533.02       328.2919       328.2919       31310.031      31310.031      1784.5732      1784.5732    
Loop time of 133.417 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.060 hours/ns, 7.495 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.79     | 132.79     | 132.79     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.08
Output  | 0.00024095 | 0.00024095 | 0.00024095 |   0.0 |  0.00
Modify  | 0.45038    | 0.45038    | 0.45038    |   0.0 |  0.34
Other   |            | 0.06686    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.695718043389, Press = -0.687609224094541
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13448.192     -13448.192     -13533.02      -13533.02       328.2919       328.2919       31310.031      31310.031      1784.5732      1784.5732    
     60000  -13442.719     -13442.719     -13528.615     -13528.615      332.42575      332.42575      31349.34       31349.34      -928.58296     -928.58296    
Loop time of 130.018 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.116 hours/ns, 7.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    | 129.41     | 129.41     | 129.41     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10642    | 0.10642    | 0.10642    |   0.0 |  0.08
Output  | 0.00024956 | 0.00024956 | 0.00024956 |   0.0 |  0.00
Modify  | 0.4335     | 0.4335     | 0.4335     |   0.0 |  0.33
Other   |            | 0.06506    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.706670131466, Press = -0.179745896279298
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13442.719     -13442.719     -13528.615     -13528.615      332.42575      332.42575      31349.34       31349.34      -928.58296     -928.58296    
     61000  -13445.099     -13445.099     -13532.077     -13532.077      336.61323      336.61323      31410.066      31410.066     -6321.0597     -6321.0597    
Loop time of 132.909 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.919 hours/ns, 7.524 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    | 132.28     | 132.28     | 132.28     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10819    | 0.10819    | 0.10819    |   0.0 |  0.08
Output  | 0.00021269 | 0.00021269 | 0.00021269 |   0.0 |  0.00
Modify  | 0.45093    | 0.45093    | 0.45093    |   0.0 |  0.34
Other   |            | 0.06574    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.776375046126, Press = -1.51875575991109
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13445.099     -13445.099     -13532.077     -13532.077      336.61323      336.61323      31410.066      31410.066     -6321.0597     -6321.0597    
     62000  -13445.187     -13445.187     -13532.3       -13532.3        337.13712      337.13712      31348.832      31348.832     -1147.6612     -1147.6612    
Loop time of 133.06 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.961 hours/ns, 7.515 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    | 132.44     | 132.44     | 132.44     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10874    | 0.10874    | 0.10874    |   0.0 |  0.08
Output  | 0.00016919 | 0.00016919 | 0.00016919 |   0.0 |  0.00
Modify  | 0.44986    | 0.44986    | 0.44986    |   0.0 |  0.34
Other   |            | 0.06565    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.762052664377, Press = -2.23274314965933
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13445.187     -13445.187     -13532.3       -13532.3        337.13712      337.13712      31348.832      31348.832     -1147.6612     -1147.6612    
     63000  -13448.646     -13448.646     -13533.824     -13533.824      329.64684      329.64684      31309.099      31309.099      1750.8064      1750.8064    
Loop time of 133.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.071 hours/ns, 7.493 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    | 132.84     | 132.84     | 132.84     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10809    | 0.10809    | 0.10809    |   0.0 |  0.08
Output  | 0.00020985 | 0.00020985 | 0.00020985 |   0.0 |  0.00
Modify  | 0.44526    | 0.44526    | 0.44526    |   0.0 |  0.33
Other   |            | 0.06566    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.737192366377, Press = -1.27366992451144
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13448.646     -13448.646     -13533.824     -13533.824      329.64684      329.64684      31309.099      31309.099      1750.8064      1750.8064    
     64000  -13443.085     -13443.085     -13530.441     -13530.441      338.07494      338.07494      31315.441      31315.441      1767.5394      1767.5394    
Loop time of 131.993 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.665 hours/ns, 7.576 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    | 131.38     | 131.38     | 131.38     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10766    | 0.10766    | 0.10766    |   0.0 |  0.08
Output  | 0.00021046 | 0.00021046 | 0.00021046 |   0.0 |  0.00
Modify  | 0.44101    | 0.44101    | 0.44101    |   0.0 |  0.33
Other   |            | 0.0654     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.726418372184, Press = -0.515663057719949
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13443.085     -13443.085     -13530.441     -13530.441      338.07494      338.07494      31315.441      31315.441      1767.5394      1767.5394    
     65000  -13447.964     -13447.964     -13532.633     -13532.633      327.67809      327.67809      31345.511      31345.511     -1251.9933     -1251.9933    
Loop time of 132.191 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.720 hours/ns, 7.565 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    | 131.57     | 131.57     | 131.57     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10775    | 0.10775    | 0.10775    |   0.0 |  0.08
Output  | 0.00016991 | 0.00016991 | 0.00016991 |   0.0 |  0.00
Modify  | 0.44474    | 0.44474    | 0.44474    |   0.0 |  0.34
Other   |            | 0.06594    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.71983617215, Press = -0.368717387643821
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13447.964     -13447.964     -13532.633     -13532.633      327.67809      327.67809      31345.511      31345.511     -1251.9933     -1251.9933    
     66000  -13440.865     -13440.865     -13527.224     -13527.224      334.21892      334.21892      31391.045      31391.045     -4108.7739     -4108.7739    
Loop time of 132.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.756 hours/ns, 7.557 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.71     | 131.71     | 131.71     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10819    | 0.10819    | 0.10819    |   0.0 |  0.08
Output  | 0.00025565 | 0.00025565 | 0.00025565 |   0.0 |  0.00
Modify  | 0.4432     | 0.4432     | 0.4432     |   0.0 |  0.33
Other   |            | 0.06564    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127968 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127968
Ave neighs/atom = 63.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.75646013623, Press = -1.46082325041265
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13440.865     -13440.865     -13527.224     -13527.224      334.21892      334.21892      31391.045      31391.045     -4108.7739     -4108.7739    
     67000  -13446.437     -13446.437     -13530.1       -13530.1        323.78402      323.78402      31335.487      31335.487      7.6033323      7.6033323    
Loop time of 129.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.028 hours/ns, 7.710 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    | 129.1      | 129.1      | 129.1      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10917    | 0.10917    | 0.10917    |   0.0 |  0.08
Output  | 0.00028369 | 0.00028369 | 0.00028369 |   0.0 |  0.00
Modify  | 0.43227    | 0.43227    | 0.43227    |   0.0 |  0.33
Other   |            | 0.06324    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 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:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.800548302371, Press = -2.4438774728845
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13446.437     -13446.437     -13530.1       -13530.1        323.78402      323.78402      31335.487      31335.487      7.6033323      7.6033323    
     68000  -13443.245     -13443.245     -13530.933     -13530.933      339.36228      339.36228      31316.162      31316.162      1731.284       1731.284     
Loop time of 133.057 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.960 hours/ns, 7.516 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    | 132.43     | 132.43     | 132.43     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11328    | 0.11328    | 0.11328    |   0.0 |  0.09
Output  | 0.00023064 | 0.00023064 | 0.00023064 |   0.0 |  0.00
Modify  | 0.45014    | 0.45014    | 0.45014    |   0.0 |  0.34
Other   |            | 0.0638     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.807025480393, Press = -1.05713156854135
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13443.245     -13443.245     -13530.933     -13530.933      339.36228      339.36228      31316.162      31316.162      1731.284       1731.284     
     69000  -13448.743     -13448.743     -13533.258     -13533.258      327.08123      327.08123      31318.603      31318.603      1246.1503      1246.1503    
Loop time of 132.739 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.872 hours/ns, 7.534 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    | 132.12     | 132.12     | 132.12     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10879    | 0.10879    | 0.10879    |   0.0 |  0.08
Output  | 0.00043389 | 0.00043389 | 0.00043389 |   0.0 |  0.00
Modify  | 0.44682    | 0.44682    | 0.44682    |   0.0 |  0.34
Other   |            | 0.06545    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.805148726701, Press = -0.646963580101076
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13448.743     -13448.743     -13533.258     -13533.258      327.08123      327.08123      31318.603      31318.603      1246.1503      1246.1503    
     70000  -13444.377     -13444.377     -13531.03      -13531.03       335.3571       335.3571       31349.262      31349.262     -1039.4559     -1039.4559    
Loop time of 128.475 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.673 ns/day, 35.687 hours/ns, 7.784 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    | 127.88     | 127.88     | 127.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10609    | 0.10609    | 0.10609    |   0.0 |  0.08
Output  | 0.00017219 | 0.00017219 | 0.00017219 |   0.0 |  0.00
Modify  | 0.42395    | 0.42395    | 0.42395    |   0.0 |  0.33
Other   |            | 0.06351    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.780078941659, Press = -0.475541322069777
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13444.377     -13444.377     -13531.03      -13531.03       335.3571       335.3571       31349.262      31349.262     -1039.4559     -1039.4559    
     71000  -13448.529     -13448.529     -13532.674     -13532.674      325.64958      325.64958      31370.021      31370.021     -3081.3322     -3081.3322    
Loop time of 131.825 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.618 hours/ns, 7.586 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    | 131.21     | 131.21     | 131.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10787    | 0.10787    | 0.10787    |   0.0 |  0.08
Output  | 0.00021143 | 0.00021143 | 0.00021143 |   0.0 |  0.00
Modify  | 0.4429     | 0.4429     | 0.4429     |   0.0 |  0.34
Other   |            | 0.06523    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.751640998837, Press = -1.30358846792968
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13448.529     -13448.529     -13532.674     -13532.674      325.64958      325.64958      31370.021      31370.021     -3081.3322     -3081.3322    
     72000  -13441.721     -13441.721     -13530.106     -13530.106      342.0584       342.0584       31331.368      31331.368      536.81065      536.81065    
Loop time of 133.017 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.949 hours/ns, 7.518 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    | 132.4      | 132.4      | 132.4      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10927    | 0.10927    | 0.10927    |   0.0 |  0.08
Output  | 0.00020476 | 0.00020476 | 0.00020476 |   0.0 |  0.00
Modify  | 0.44621    | 0.44621    | 0.44621    |   0.0 |  0.34
Other   |            | 0.06562    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.760893703714, Press = -2.11725038027702
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13441.721     -13441.721     -13530.106     -13530.106      342.0584       342.0584       31331.368      31331.368      536.81065      536.81065    
     73000  -13445.688     -13445.688     -13530.307     -13530.307      327.48293      327.48293      31303.813      31303.813      2819.6781      2819.6781    
Loop time of 130.157 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.664 ns/day, 36.155 hours/ns, 7.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    | 129.55     | 129.55     | 129.55     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10596    | 0.10596    | 0.10596    |   0.0 |  0.08
Output  | 0.00017007 | 0.00017007 | 0.00017007 |   0.0 |  0.00
Modify  | 0.43648    | 0.43648    | 0.43648    |   0.0 |  0.34
Other   |            | 0.06517    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.811351862464, Press = -0.840537630817023
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13445.688     -13445.688     -13530.307     -13530.307      327.48293      327.48293      31303.813      31303.813      2819.6781      2819.6781    
     74000  -13445.012     -13445.012     -13529.949     -13529.949      328.71271      328.71271      31325.323      31325.323      888.67626      888.67626    
Loop time of 130.756 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.321 hours/ns, 7.648 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.15     | 130.15     | 130.15     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10697    | 0.10697    | 0.10697    |   0.0 |  0.08
Output  | 0.00020179 | 0.00020179 | 0.00020179 |   0.0 |  0.00
Modify  | 0.43706    | 0.43706    | 0.43706    |   0.0 |  0.33
Other   |            | 0.06522    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.807306154802, Press = -0.510960675459838
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13445.012     -13445.012     -13529.949     -13529.949      328.71271      328.71271      31325.323      31325.323      888.67626      888.67626    
     75000  -13443.343     -13443.343     -13530.59      -13530.59       337.65348      337.65348      31344.822      31344.822     -693.61132     -693.61132    
Loop time of 128.25 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.625 hours/ns, 7.797 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    | 127.65     | 127.65     | 127.65     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1062     | 0.1062     | 0.1062     |   0.0 |  0.08
Output  | 0.00016719 | 0.00016719 | 0.00016719 |   0.0 |  0.00
Modify  | 0.42768    | 0.42768    | 0.42768    |   0.0 |  0.33
Other   |            | 0.06449    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.803974258257, Press = -0.63767444629707
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -13443.343     -13443.343     -13530.59      -13530.59       337.65348      337.65348      31344.822      31344.822     -693.61132     -693.61132    
     76000  -13445.229     -13445.229     -13533.327     -13533.327      340.94669      340.94669      31356.342      31356.342     -1743.7347     -1743.7347    
Loop time of 132.36 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.767 hours/ns, 7.555 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.74     | 131.74     | 131.74     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11285    | 0.11285    | 0.11285    |   0.0 |  0.09
Output  | 0.00021873 | 0.00021873 | 0.00021873 |   0.0 |  0.00
Modify  | 0.44244    | 0.44244    | 0.44244    |   0.0 |  0.33
Other   |            | 0.06472    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.760904783371, Press = -1.2882108785334
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -13445.229     -13445.229     -13533.327     -13533.327      340.94669      340.94669      31356.342      31356.342     -1743.7347     -1743.7347    
     77000  -13443.537     -13443.537     -13528.939     -13528.939      330.51489      330.51489      31312.956      31312.956      2377.9675      2377.9675    
Loop time of 134.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.258 hours/ns, 7.456 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.5      | 133.5      | 133.5      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11313    | 0.11313    | 0.11313    |   0.0 |  0.08
Output  | 0.00021499 | 0.00021499 | 0.00021499 |   0.0 |  0.00
Modify  | 0.44669    | 0.44669    | 0.44669    |   0.0 |  0.33
Other   |            | 0.0653     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.739386810999, Press = -1.75846771547938
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -13443.537     -13443.537     -13528.939     -13528.939      330.51489      330.51489      31312.956      31312.956      2377.9675      2377.9675    
     78000  -13443.711     -13443.711     -13528.795     -13528.795      329.28497      329.28497      31291.381      31291.381      4163.2272      4163.2272    
Loop time of 119.918 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.720 ns/day, 33.311 hours/ns, 8.339 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    | 119.37     | 119.37     | 119.37     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10024    | 0.10024    | 0.10024    |   0.0 |  0.08
Output  | 0.00016819 | 0.00016819 | 0.00016819 |   0.0 |  0.00
Modify  | 0.38521    | 0.38521    | 0.38521    |   0.0 |  0.32
Other   |            | 0.06136    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.776239299221, Press = -0.53661106903847
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -13443.711     -13443.711     -13528.795     -13528.795      329.28497      329.28497      31291.381      31291.381      4163.2272      4163.2272    
     79000  -13443.363     -13443.363     -13531.785     -13531.785      342.20043      342.20043      31334.595      31334.595      33.214634      33.214634    
Loop time of 131.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.591 hours/ns, 7.591 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    | 131.11     | 131.11     | 131.11     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10848    | 0.10848    | 0.10848    |   0.0 |  0.08
Output  | 0.00025282 | 0.00025282 | 0.00025282 |   0.0 |  0.00
Modify  | 0.4413     | 0.4413     | 0.4413     |   0.0 |  0.34
Other   |            | 0.06629    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.793899649527, Press = -0.163196241031111
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -13443.363     -13443.363     -13531.785     -13531.785      342.20043      342.20043      31334.595      31334.595      33.214634      33.214634    
     80000  -13447.949     -13447.949     -13534.129     -13534.129      333.52678      333.52678      31354.403      31354.403     -2110.1983     -2110.1983    
Loop time of 129.386 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.668 ns/day, 35.940 hours/ns, 7.729 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    | 128.78     | 128.78     | 128.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10751    | 0.10751    | 0.10751    |   0.0 |  0.08
Output  | 0.00020046 | 0.00020046 | 0.00020046 |   0.0 |  0.00
Modify  | 0.43044    | 0.43044    | 0.43044    |   0.0 |  0.33
Other   |            | 0.06411    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.78651718073, Press = -0.535282112117093
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -13447.949     -13447.949     -13534.129     -13534.129      333.52678      333.52678      31354.403      31354.403     -2110.1983     -2110.1983    
     81000  -13446.306     -13446.306     -13530.436     -13530.436      325.59007      325.59007      31356.988      31356.988     -1903.8563     -1903.8563    
Loop time of 128.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.751 hours/ns, 7.770 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    | 128.11     | 128.11     | 128.11     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10734    | 0.10734    | 0.10734    |   0.0 |  0.08
Output  | 0.00016758 | 0.00016758 | 0.00016758 |   0.0 |  0.00
Modify  | 0.42621    | 0.42621    | 0.42621    |   0.0 |  0.33
Other   |            | 0.06354    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.775130208403, Press = -1.13504659461099
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -13446.306     -13446.306     -13530.436     -13530.436      325.59007      325.59007      31356.988      31356.988     -1903.8563     -1903.8563    
     82000  -13442.869     -13442.869     -13529.249     -13529.249      334.30142      334.30142      31321.509      31321.509      1437.3543      1437.3543    
Loop time of 133.19 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.997 hours/ns, 7.508 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    | 132.57     | 132.57     | 132.57     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1091     | 0.1091     | 0.1091     |   0.0 |  0.08
Output  | 0.00016889 | 0.00016889 | 0.00016889 |   0.0 |  0.00
Modify  | 0.4487     | 0.4487     | 0.4487     |   0.0 |  0.34
Other   |            | 0.06594    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.751298077487, Press = -1.31657719030888
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -13442.869     -13442.869     -13529.249     -13529.249      334.30142      334.30142      31321.509      31321.509      1437.3543      1437.3543    
     83000  -13445.033     -13445.033     -13531.741     -13531.741      335.56721      335.56721      31285.248      31285.248      4298.438       4298.438     
Loop time of 124.337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.538 hours/ns, 8.043 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    | 123.76     | 123.76     | 123.76     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10229    | 0.10229    | 0.10229    |   0.0 |  0.08
Output  | 0.00025248 | 0.00025248 | 0.00025248 |   0.0 |  0.00
Modify  | 0.40845    | 0.40845    | 0.40845    |   0.0 |  0.33
Other   |            | 0.06182    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.763076244591, Press = -0.297654544310889
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -13445.033     -13445.033     -13531.741     -13531.741      335.56721      335.56721      31285.248      31285.248      4298.438       4298.438     
     84000  -13446.649     -13446.649     -13531.982     -13531.982      330.25006      330.25006      31328.016      31328.016      595.64475      595.64475    
Loop time of 132.7 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.861 hours/ns, 7.536 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    | 132.07     | 132.07     | 132.07     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1094     | 0.1094     | 0.1094     |   0.0 |  0.08
Output  | 0.00020491 | 0.00020491 | 0.00020491 |   0.0 |  0.00
Modify  | 0.4498     | 0.4498     | 0.4498     |   0.0 |  0.34
Other   |            | 0.06584    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127988 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.807186385638, Press = 0.558006688743543
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -13446.649     -13446.649     -13531.982     -13531.982      330.25006      330.25006      31328.016      31328.016      595.64475      595.64475    
     85000  -13445.103     -13445.103     -13532.862     -13532.862      339.63368      339.63368      31356.896      31356.896     -1921.5073     -1921.5073    
Loop time of 131.154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.432 hours/ns, 7.625 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    | 130.54     | 130.54     | 130.54     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10923    | 0.10923    | 0.10923    |   0.0 |  0.08
Output  | 0.00016842 | 0.00016842 | 0.00016842 |   0.0 |  0.00
Modify  | 0.43938    | 0.43938    | 0.43938    |   0.0 |  0.34
Other   |            | 0.06509    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.830249106823, Press = -0.412490312710231
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -13445.103     -13445.103     -13532.862     -13532.862      339.63368      339.63368      31356.896      31356.896     -1921.5073     -1921.5073    
     86000  -13448.062     -13448.062     -13533.579     -13533.579      330.95946      330.95946      31344.992      31344.992     -1075.6975     -1075.6975    
Loop time of 132.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.893 hours/ns, 7.529 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.2      | 132.2      | 132.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11108    | 0.11108    | 0.11108    |   0.0 |  0.08
Output  | 0.00016808 | 0.00016808 | 0.00016808 |   0.0 |  0.00
Modify  | 0.44475    | 0.44475    | 0.44475    |   0.0 |  0.33
Other   |            | 0.06529    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.854033687129, Press = -0.821113753065048
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -13448.062     -13448.062     -13533.579     -13533.579      330.95946      330.95946      31344.992      31344.992     -1075.6975     -1075.6975    
     87000  -13442.454     -13442.454     -13530.968     -13530.968      342.55854      342.55854      31332.254      31332.254      466.90271      466.90271    
Loop time of 114.663 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.851 hours/ns, 8.721 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    | 114.15     | 114.15     | 114.15     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094966   | 0.094966   | 0.094966   |   0.0 |  0.08
Output  | 0.00019752 | 0.00019752 | 0.00019752 |   0.0 |  0.00
Modify  | 0.36194    | 0.36194    | 0.36194    |   0.0 |  0.32
Other   |            | 0.05862    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.876633651367, Press = -0.949042681845445
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -13442.454     -13442.454     -13530.968     -13530.968      342.55854      342.55854      31332.254      31332.254      466.90271      466.90271    
     88000  -13446.486     -13446.486     -13531.318     -13531.318      328.30734      328.30734      31289.595      31289.595      3613.5555      3613.5555    
Loop time of 114.043 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.679 hours/ns, 8.769 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.53     | 113.53     | 113.53     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094775   | 0.094775   | 0.094775   |   0.0 |  0.08
Output  | 0.00019943 | 0.00019943 | 0.00019943 |   0.0 |  0.00
Modify  | 0.36242    | 0.36242    | 0.36242    |   0.0 |  0.32
Other   |            | 0.05884    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.899276940197, Press = -0.233015470851676
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -13446.486     -13446.486     -13531.318     -13531.318      328.30734      328.30734      31289.595      31289.595      3613.5555      3613.5555    
     89000  -13445.205     -13445.205     -13530.149     -13530.149      328.74209      328.74209      31333.432      31333.432      269.53615      269.53615    
Loop time of 114.039 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.677 hours/ns, 8.769 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.52     | 113.52     | 113.52     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094805   | 0.094805   | 0.094805   |   0.0 |  0.08
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.36085    | 0.36085    | 0.36085    |   0.0 |  0.32
Other   |            | 0.05907    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127988 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.900606178104, Press = 0.545620356772837
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -13445.205     -13445.205     -13530.149     -13530.149      328.74209      328.74209      31333.432      31333.432      269.53615      269.53615    
     90000  -13450.372     -13450.372     -13533.96      -13533.96       323.49704      323.49704      31368.068      31368.068     -3269.2942     -3269.2942    
Loop time of 124.589 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.693 ns/day, 34.608 hours/ns, 8.026 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.01     | 124.01     | 124.01     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10238    | 0.10238    | 0.10238    |   0.0 |  0.08
Output  | 0.0001684  | 0.0001684  | 0.0001684  |   0.0 |  0.00
Modify  | 0.40898    | 0.40898    | 0.40898    |   0.0 |  0.33
Other   |            | 0.06313    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.868336516619, Press = -0.403084969075494
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -13450.372     -13450.372     -13533.96      -13533.96       323.49704      323.49704      31368.068      31368.068     -3269.2942     -3269.2942    
     91000  -13446.211     -13446.211     -13531.879     -13531.879      331.54696      331.54696      31349.77       31349.77      -1320.3225     -1320.3225    
Loop time of 123.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.441 hours/ns, 8.065 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    | 123.42     | 123.42     | 123.42     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10209    | 0.10209    | 0.10209    |   0.0 |  0.08
Output  | 0.00016921 | 0.00016921 | 0.00016921 |   0.0 |  0.00
Modify  | 0.40499    | 0.40499    | 0.40499    |   0.0 |  0.33
Other   |            | 0.06209    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.86840385169, Press = -1.03224445118542
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -13446.211     -13446.211     -13531.879     -13531.879      331.54696      331.54696      31349.77       31349.77      -1320.3225     -1320.3225    
     92000  -13447.157     -13447.157     -13532.345     -13532.345      329.68552      329.68552      31312.604      31312.604      1778.9312      1778.9312    
Loop time of 114.27 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.742 hours/ns, 8.751 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.75     | 113.75     | 113.75     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096174   | 0.096174   | 0.096174   |   0.0 |  0.08
Output  | 0.00016866 | 0.00016866 | 0.00016866 |   0.0 |  0.00
Modify  | 0.36207    | 0.36207    | 0.36207    |   0.0 |  0.32
Other   |            | 0.05743    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.88146824805, Press = -0.830046340678942
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -13447.157     -13447.157     -13532.345     -13532.345      329.68552      329.68552      31312.604      31312.604      1778.9312      1778.9312    
     93000  -13443.177     -13443.177     -13527.118     -13527.118      324.85827      324.85827      31314.761      31314.761      1949.0015      1949.0015    
Loop time of 114.447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.791 hours/ns, 8.738 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.93     | 113.93     | 113.93     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096476   | 0.096476   | 0.096476   |   0.0 |  0.08
Output  | 0.0001695  | 0.0001695  | 0.0001695  |   0.0 |  0.00
Modify  | 0.36361    | 0.36361    | 0.36361    |   0.0 |  0.32
Other   |            | 0.05817    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.907146552188, Press = -0.114293764702269
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -13443.177     -13443.177     -13527.118     -13527.118      324.85827      324.85827      31314.761      31314.761      1949.0015      1949.0015    
     94000  -13446.861     -13446.861     -13533.073     -13533.073      333.64738      333.64738      31365.112      31365.112     -2868.1156     -2868.1156    
Loop time of 114.255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.737 hours/ns, 8.752 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    | 113.74     | 113.74     | 113.74     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095284   | 0.095284   | 0.095284   |   0.0 |  0.08
Output  | 0.00016889 | 0.00016889 | 0.00016889 |   0.0 |  0.00
Modify  | 0.3594     | 0.3594     | 0.3594     |   0.0 |  0.31
Other   |            | 0.0576     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127976 ave      127976 max      127976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127976
Ave neighs/atom = 63.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.9035628387, Press = 0.298891590655051
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -13446.861     -13446.861     -13533.073     -13533.073      333.64738      333.64738      31365.112      31365.112     -2868.1156     -2868.1156    
     95000  -13445.786     -13445.786     -13531.711     -13531.711      332.53831      332.53831      31383.288      31383.288     -3946.3434     -3946.3434    
Loop time of 114.356 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.766 hours/ns, 8.745 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.84     | 113.84     | 113.84     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095258   | 0.095258   | 0.095258   |   0.0 |  0.08
Output  | 0.00016663 | 0.00016663 | 0.00016663 |   0.0 |  0.00
Modify  | 0.36049    | 0.36049    | 0.36049    |   0.0 |  0.32
Other   |            | 0.05776    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127974 ave      127974 max      127974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127974
Ave neighs/atom = 63.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.891964301828, Press = -0.7709036624998
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -13445.786     -13445.786     -13531.711     -13531.711      332.53831      332.53831      31383.288      31383.288     -3946.3434     -3946.3434    
     96000  -13441.816     -13441.816     -13530.268     -13530.268      342.31864      342.31864      31341.487      31341.487     -100.79196     -100.79196    
Loop time of 114.256 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.738 hours/ns, 8.752 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.74     | 113.74     | 113.74     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09595    | 0.09595    | 0.09595    |   0.0 |  0.08
Output  | 0.00017043 | 0.00017043 | 0.00017043 |   0.0 |  0.00
Modify  | 0.35953    | 0.35953    | 0.35953    |   0.0 |  0.31
Other   |            | 0.05795    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.88949830531, Press = -0.850522938378998
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -13441.816     -13441.816     -13530.268     -13530.268      342.31864      342.31864      31341.487      31341.487     -100.79196     -100.79196    
     97000  -13447.058     -13447.058     -13533.375     -13533.375      334.05696      334.05696      31312.362      31312.362      1645.6925      1645.6925    
Loop time of 121.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.723 hours/ns, 8.237 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    | 120.85     | 120.85     | 120.85     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10105    | 0.10105    | 0.10105    |   0.0 |  0.08
Output  | 0.00016821 | 0.00016821 | 0.00016821 |   0.0 |  0.00
Modify  | 0.39273    | 0.39273    | 0.39273    |   0.0 |  0.32
Other   |            | 0.06034    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127984 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.904464264222, Press = -0.376255832580042
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -13447.058     -13447.058     -13533.375     -13533.375      334.05696      334.05696      31312.362      31312.362      1645.6925      1645.6925    
     98000  -13441.364     -13441.364     -13528.635     -13528.635      337.7472       337.7472       31337.65       31337.65       358.55108      358.55108    
Loop time of 127.178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.327 hours/ns, 7.863 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    | 126.59     | 126.59     | 126.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10432    | 0.10432    | 0.10432    |   0.0 |  0.08
Output  | 0.00022836 | 0.00022836 | 0.00022836 |   0.0 |  0.00
Modify  | 0.41962    | 0.41962    | 0.41962    |   0.0 |  0.33
Other   |            | 0.06367    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127982 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.919898034139, Press = 0.0380422069133853
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -13441.364     -13441.364     -13528.635     -13528.635      337.7472       337.7472       31337.65       31337.65       358.55108      358.55108    
     99000  -13446.402     -13446.402     -13531.986     -13531.986      331.21951      331.21951      31372.907      31372.907     -3272.1919     -3272.1919    
Loop time of 126.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.111 hours/ns, 7.911 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    | 125.82     | 125.82     | 125.82     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10417    | 0.10417    | 0.10417    |   0.0 |  0.08
Output  | 0.00020453 | 0.00020453 | 0.00020453 |   0.0 |  0.00
Modify  | 0.41411    | 0.41411    | 0.41411    |   0.0 |  0.33
Other   |            | 0.06302    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.940556752545, Press = -0.27350802206722
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -13446.402     -13446.402     -13531.986     -13531.986      331.21951      331.21951      31372.907      31372.907     -3272.1919     -3272.1919    
    100000  -13443.772     -13443.772     -13528.575     -13528.575      328.1968       328.1968       31394.361      31394.361     -4469.6127     -4469.6127    
Loop time of 132.597 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.833 hours/ns, 7.542 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    | 131.97     | 131.97     | 131.97     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10971    | 0.10971    | 0.10971    |   0.0 |  0.08
Output  | 0.00057954 | 0.00057954 | 0.00057954 |   0.0 |  0.00
Modify  | 0.44669    | 0.44669    | 0.44669    |   0.0 |  0.34
Other   |            | 0.06549    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.974414250342, Press = -1.51180428810034
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -13443.772     -13443.772     -13528.575     -13528.575      328.1968       328.1968       31394.361      31394.361     -4469.6127     -4469.6127    
    101000  -13447.958     -13447.958     -13531.218     -13531.218      322.22463      322.22463      31312.672      31312.672      2020.2461      2020.2461    
Loop time of 118.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.818 hours/ns, 8.464 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    | 117.6      | 117.6      | 117.6      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098803   | 0.098803   | 0.098803   |   0.0 |  0.08
Output  | 0.00016694 | 0.00016694 | 0.00016694 |   0.0 |  0.00
Modify  | 0.3798     | 0.3798     | 0.3798     |   0.0 |  0.32
Other   |            | 0.06114    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127970 ave      127970 max      127970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127970
Ave neighs/atom = 63.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.97057909502, Press = -0.817045894498975
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -13447.958     -13447.958     -13531.218     -13531.218      322.22463      322.22463      31312.672      31312.672      2020.2461      2020.2461    
    102000  -13445.657     -13445.657     -13532.371     -13532.371      335.59227      335.59227      31305.004      31305.004      2383.7447      2383.7447    
Loop time of 127.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.676 ns/day, 35.508 hours/ns, 7.823 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    | 127.24     | 127.24     | 127.24     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10638    | 0.10638    | 0.10638    |   0.0 |  0.08
Output  | 0.00021228 | 0.00021228 | 0.00021228 |   0.0 |  0.00
Modify  | 0.42344    | 0.42344    | 0.42344    |   0.0 |  0.33
Other   |            | 0.06374    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127980 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0