# 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.5090000331401834*${_u_distance}
variable latticeconst_converted equal 3.5090000331401834*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.50900003314018
Lattice spacing in x,y,z = 3.509 3.509 3.509
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.09 35.09 35.09)
  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 (35.09 35.09 35.09)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_RoyDuttaChakraborti_2021_AlLi__MO_971738391444_001
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -3224.2527     -3224.2527     -3300          -3300           293.15         293.15         43206.602      43206.602      1872.559       1872.559     
      1000  -3202.3371     -3202.3371     -3278.1856     -3278.1856      293.54162      293.54162      47095.873      47095.873      449.02295      449.02295    
Loop time of 17.2598 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.006 ns/day, 4.794 hours/ns, 57.938 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.058     | 17.058     | 17.058     |   0.0 | 98.83
Neigh   | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.70
Comm    | 0.014345   | 0.014345   | 0.014345   |   0.0 |  0.08
Output  | 0.00022391 | 0.00022391 | 0.00022391 |   0.0 |  0.00
Modify  | 0.061087   | 0.061087   | 0.061087   |   0.0 |  0.35
Other   |            | 0.005082   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3308 ave        3308 max        3308 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119276 ave      119276 max      119276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119276
Ave neighs/atom = 59.638
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -3202.3371     -3202.3371     -3278.1856     -3278.1856      293.54162      293.54162      47095.873      47095.873      449.02295      449.02295    
      2000  -3200.4666     -3200.4666     -3277.2026     -3277.2026      296.97614      296.97614      47313.629      47313.629      32.483994      32.483994    
Loop time of 17.138 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.041 ns/day, 4.761 hours/ns, 58.350 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.942     | 16.942     | 16.942     |   0.0 | 98.85
Neigh   | 0.11802    | 0.11802    | 0.11802    |   0.0 |  0.69
Comm    | 0.013718   | 0.013718   | 0.013718   |   0.0 |  0.08
Output  | 8.2505e-05 | 8.2505e-05 | 8.2505e-05 |   0.0 |  0.00
Modify  | 0.059804   | 0.059804   | 0.059804   |   0.0 |  0.35
Other   |            | 0.004682   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3294 ave        3294 max        3294 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119472 ave      119472 max      119472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119472
Ave neighs/atom = 59.736
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3200.4666     -3200.4666     -3277.2026     -3277.2026      296.97614      296.97614      47313.629      47313.629      32.483994      32.483994    
      3000  -3199.6129     -3199.6129     -3277.6928     -3277.6928      302.17721      302.17721      47342.911      47342.911     -104.49734     -104.49734    
Loop time of 17.0993 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.053 ns/day, 4.750 hours/ns, 58.482 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.905     | 16.905     | 16.905     |   0.0 | 98.87
Neigh   | 0.11601    | 0.11601    | 0.11601    |   0.0 |  0.68
Comm    | 0.013566   | 0.013566   | 0.013566   |   0.0 |  0.08
Output  | 3.8713e-05 | 3.8713e-05 | 3.8713e-05 |   0.0 |  0.00
Modify  | 0.059701   | 0.059701   | 0.059701   |   0.0 |  0.35
Other   |            | 0.004578   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3293 ave        3293 max        3293 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119484 ave      119484 max      119484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119484
Ave neighs/atom = 59.742
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -3199.6129     -3199.6129     -3277.6928     -3277.6928      302.17721      302.17721      47342.911      47342.911     -104.49734     -104.49734    
      4000  -3202.9796     -3202.9796     -3279.0369     -3279.0369      294.34982      294.34982      47302.326      47302.326     -128.46782     -128.46782    
Loop time of 17.065 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.063 ns/day, 4.740 hours/ns, 58.599 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.876     | 16.876     | 16.876     |   0.0 | 98.89
Neigh   | 0.11152    | 0.11152    | 0.11152    |   0.0 |  0.65
Comm    | 0.013462   | 0.013462   | 0.013462   |   0.0 |  0.08
Output  | 2.6539e-05 | 2.6539e-05 | 2.6539e-05 |   0.0 |  0.00
Modify  | 0.059588   | 0.059588   | 0.059588   |   0.0 |  0.35
Other   |            | 0.00456    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3226 ave        3226 max        3226 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119368 ave      119368 max      119368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119368
Ave neighs/atom = 59.684
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -3202.9796     -3202.9796     -3279.0369     -3279.0369      294.34982      294.34982      47302.326      47302.326     -128.46782     -128.46782    
      5000  -3200.9302     -3200.9302     -3275.5009     -3275.5009      288.59625      288.59625      47375.849      47375.849     -210.96775     -210.96775    
Loop time of 17.1664 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.033 ns/day, 4.768 hours/ns, 58.253 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.977     | 16.977     | 16.977     |   0.0 | 98.90
Neigh   | 0.11141    | 0.11141    | 0.11141    |   0.0 |  0.65
Comm    | 0.013407   | 0.013407   | 0.013407   |   0.0 |  0.08
Output  | 2.2231e-05 | 2.2231e-05 | 2.2231e-05 |   0.0 |  0.00
Modify  | 0.059935   | 0.059935   | 0.059935   |   0.0 |  0.35
Other   |            | 0.004562   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3290 ave        3290 max        3290 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119392 ave      119392 max      119392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119392
Ave neighs/atom = 59.696
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 296.346284630945, Press = -51.901646054558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3200.9302     -3200.9302     -3275.5009     -3275.5009      288.59625      288.59625      47375.849      47375.849     -210.96775     -210.96775    
      6000  -3200.7219     -3200.7219     -3275.3911     -3275.3911      288.97738      288.97738      47569.533      47569.533     -698.96435     -698.96435    
Loop time of 17.0926 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.055 ns/day, 4.748 hours/ns, 58.505 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.897     | 16.897     | 16.897     |   0.0 | 98.85
Neigh   | 0.1153     | 0.1153     | 0.1153     |   0.0 |  0.67
Comm    | 0.013627   | 0.013627   | 0.013627   |   0.0 |  0.08
Output  | 4.0185e-05 | 4.0185e-05 | 4.0185e-05 |   0.0 |  0.00
Modify  | 0.062096   | 0.062096   | 0.062096   |   0.0 |  0.36
Other   |            | 0.004656   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3291 ave        3291 max        3291 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119066 ave      119066 max      119066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119066
Ave neighs/atom = 59.533
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.888189020381, Press = 2.01113354145865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3200.7219     -3200.7219     -3275.3911     -3275.3911      288.97738      288.97738      47569.533      47569.533     -698.96435     -698.96435    
      7000  -3202.6891     -3202.6891     -3277.1922     -3277.1922      288.33494      288.33494      47254.945      47254.945      213.07637      213.07637    
Loop time of 17.1788 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.029 ns/day, 4.772 hours/ns, 58.211 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.983     | 16.983     | 16.983     |   0.0 | 98.86
Neigh   | 0.11513    | 0.11513    | 0.11513    |   0.0 |  0.67
Comm    | 0.013566   | 0.013566   | 0.013566   |   0.0 |  0.08
Output  | 3.4084e-05 | 3.4084e-05 | 3.4084e-05 |   0.0 |  0.00
Modify  | 0.062012   | 0.062012   | 0.062012   |   0.0 |  0.36
Other   |            | 0.004594   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3291 ave        3291 max        3291 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119418 ave      119418 max      119418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119418
Ave neighs/atom = 59.709
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.934799675662, Press = -22.7970572538237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3202.6891     -3202.6891     -3277.1922     -3277.1922      288.33494      288.33494      47254.945      47254.945      213.07637      213.07637    
      8000  -3202.5094     -3202.5094     -3281.4425     -3281.4425      305.47907      305.47907      47225.478      47225.478      395.21077      395.21077    
Loop time of 17.2472 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.010 ns/day, 4.791 hours/ns, 57.980 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.053     | 17.053     | 17.053     |   0.0 | 98.87
Neigh   | 0.1141     | 0.1141     | 0.1141     |   0.0 |  0.66
Comm    | 0.013609   | 0.013609   | 0.013609   |   0.0 |  0.08
Output  | 2.2152e-05 | 2.2152e-05 | 2.2152e-05 |   0.0 |  0.00
Modify  | 0.061954   | 0.061954   | 0.061954   |   0.0 |  0.36
Other   |            | 0.004569   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3289 ave        3289 max        3289 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119526 ave      119526 max      119526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119526
Ave neighs/atom = 59.763
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.413571809075, Press = -1.36887566721392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3202.5094     -3202.5094     -3281.4425     -3281.4425      305.47907      305.47907      47225.478      47225.478      395.21077      395.21077    
      9000  -3206.3504     -3206.3504     -3281.1898     -3281.1898      289.63593      289.63593      47401.632      47401.632     -167.05758     -167.05758    
Loop time of 17.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.996 ns/day, 4.804 hours/ns, 57.827 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.099     | 17.099     | 17.099     |   0.0 | 98.88
Neigh   | 0.11364    | 0.11364    | 0.11364    |   0.0 |  0.66
Comm    | 0.013601   | 0.013601   | 0.013601   |   0.0 |  0.08
Output  | 2.2071e-05 | 2.2071e-05 | 2.2071e-05 |   0.0 |  0.00
Modify  | 0.061901   | 0.061901   | 0.061901   |   0.0 |  0.36
Other   |            | 0.004589   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3315 ave        3315 max        3315 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119338 ave      119338 max      119338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119338
Ave neighs/atom = 59.669
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.553777231247, Press = 3.50677391028385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3206.3504     -3206.3504     -3281.1898     -3281.1898      289.63593      289.63593      47401.632      47401.632     -167.05758     -167.05758    
     10000  -3209.8928     -3209.8928     -3283.6661     -3283.6661      285.51008      285.51008      47391.168      47391.168     -129.17377     -129.17377    
Loop time of 17.2932 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.996 ns/day, 4.804 hours/ns, 57.826 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.1       | 17.1       | 17.1       |   0.0 | 98.88
Neigh   | 0.11312    | 0.11312    | 0.11312    |   0.0 |  0.65
Comm    | 0.013587   | 0.013587   | 0.013587   |   0.0 |  0.08
Output  | 3.1008e-05 | 3.1008e-05 | 3.1008e-05 |   0.0 |  0.00
Modify  | 0.062011   | 0.062011   | 0.062011   |   0.0 |  0.36
Other   |            | 0.004608   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3322 ave        3322 max        3322 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119280 ave      119280 max      119280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119280
Ave neighs/atom = 59.64
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.784043563907, Press = 2.48567143499735
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3209.8928     -3209.8928     -3283.6661     -3283.6661      285.51008      285.51008      47391.168      47391.168     -129.17377     -129.17377    
     11000  -3208.4967     -3208.4967     -3282.947      -3282.947       288.13023      288.13023      47491.741      47491.741     -278.90505     -278.90505    
Loop time of 17.3038 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.993 ns/day, 4.807 hours/ns, 57.791 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.115     | 17.115     | 17.115     |   0.0 | 98.91
Neigh   | 0.10824    | 0.10824    | 0.10824    |   0.0 |  0.63
Comm    | 0.013509   | 0.013509   | 0.013509   |   0.0 |  0.08
Output  | 2.2182e-05 | 2.2182e-05 | 2.2182e-05 |   0.0 |  0.00
Modify  | 0.061962   | 0.061962   | 0.061962   |   0.0 |  0.36
Other   |            | 0.004615   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3307 ave        3307 max        3307 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118810 ave      118810 max      118810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118810
Ave neighs/atom = 59.405
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.466602718272, Press = -2.60606040279637
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3208.4967     -3208.4967     -3282.947      -3282.947       288.13023      288.13023      47491.741      47491.741     -278.90505     -278.90505    
     12000  -3204.2803     -3204.2803     -3280.9696     -3280.9696      296.7957       296.7957       47365.437      47365.437      29.445714      29.445714    
Loop time of 17.3213 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.988 ns/day, 4.811 hours/ns, 57.732 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.122     | 17.122     | 17.122     |   0.0 | 98.85
Neigh   | 0.11869    | 0.11869    | 0.11869    |   0.0 |  0.69
Comm    | 0.013656   | 0.013656   | 0.013656   |   0.0 |  0.08
Output  | 2.2121e-05 | 2.2121e-05 | 2.2121e-05 |   0.0 |  0.00
Modify  | 0.061879   | 0.061879   | 0.061879   |   0.0 |  0.36
Other   |            | 0.0046     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3328 ave        3328 max        3328 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119122 ave      119122 max      119122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119122
Ave neighs/atom = 59.561
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.605833195516, Press = -5.31465896472196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -3204.2803     -3204.2803     -3280.9696     -3280.9696      296.7957       296.7957       47365.437      47365.437      29.445714      29.445714    
     13000  -3205.2684     -3205.2684     -3281.7816     -3281.7816      296.11401      296.11401      47234.346      47234.346      272.0725       272.0725     
Loop time of 17.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.001 ns/day, 4.799 hours/ns, 57.884 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.084     | 17.084     | 17.084     |   0.0 | 98.89
Neigh   | 0.11239    | 0.11239    | 0.11239    |   0.0 |  0.65
Comm    | 0.013579   | 0.013579   | 0.013579   |   0.0 |  0.08
Output  | 2.2462e-05 | 2.2462e-05 | 2.2462e-05 |   0.0 |  0.00
Modify  | 0.06193    | 0.06193    | 0.06193    |   0.0 |  0.36
Other   |            | 0.004597   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3327 ave        3327 max        3327 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119334 ave      119334 max      119334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119334
Ave neighs/atom = 59.667
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.586646057192, Press = -2.90866383497631
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -3205.2684     -3205.2684     -3281.7816     -3281.7816      296.11401      296.11401      47234.346      47234.346      272.0725       272.0725     
     14000  -3201.8815     -3201.8815     -3280.135      -3280.135       302.84888      302.84888      47263.62       47263.62       333.70392      333.70392    
Loop time of 17.2704 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.003 ns/day, 4.797 hours/ns, 57.903 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.077     | 17.077     | 17.077     |   0.0 | 98.88
Neigh   | 0.11328    | 0.11328    | 0.11328    |   0.0 |  0.66
Comm    | 0.013561   | 0.013561   | 0.013561   |   0.0 |  0.08
Output  | 7.7986e-05 | 7.7986e-05 | 7.7986e-05 |   0.0 |  0.00
Modify  | 0.061924   | 0.061924   | 0.061924   |   0.0 |  0.36
Other   |            | 0.004607   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3339 ave        3339 max        3339 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119586 ave      119586 max      119586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119586
Ave neighs/atom = 59.793
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.765762793491, Press = 2.12774305480541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3201.8815     -3201.8815     -3280.135      -3280.135       302.84888      302.84888      47263.62       47263.62       333.70392      333.70392    
     15000  -3206.7324     -3206.7324     -3282.4186     -3282.4186      292.91325      292.91325      47524.833      47524.833     -349.5421      -349.5421     
Loop time of 17.2844 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.999 ns/day, 4.801 hours/ns, 57.856 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.091     | 17.091     | 17.091     |   0.0 | 98.88
Neigh   | 0.11304    | 0.11304    | 0.11304    |   0.0 |  0.65
Comm    | 0.013598   | 0.013598   | 0.013598   |   0.0 |  0.08
Output  | 2.1871e-05 | 2.1871e-05 | 2.1871e-05 |   0.0 |  0.00
Modify  | 0.061781   | 0.061781   | 0.061781   |   0.0 |  0.36
Other   |            | 0.004604   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3283 ave        3283 max        3283 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119138 ave      119138 max      119138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119138
Ave neighs/atom = 59.569
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.71614366027, Press = 1.74572215391031
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -3206.7324     -3206.7324     -3282.4186     -3282.4186      292.91325      292.91325      47524.833      47524.833     -349.5421      -349.5421     
     16000  -3210.9013     -3210.9013     -3284.8508     -3284.8508      286.19249      286.19249      47409.784      47409.784     -264.06409     -264.06409    
Loop time of 17.2597 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.006 ns/day, 4.794 hours/ns, 57.938 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.067     | 17.067     | 17.067     |   0.0 | 98.88
Neigh   | 0.11308    | 0.11308    | 0.11308    |   0.0 |  0.66
Comm    | 0.013585   | 0.013585   | 0.013585   |   0.0 |  0.08
Output  | 2.1771e-05 | 2.1771e-05 | 2.1771e-05 |   0.0 |  0.00
Modify  | 0.061746   | 0.061746   | 0.061746   |   0.0 |  0.36
Other   |            | 0.004594   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3306 ave        3306 max        3306 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119010 ave      119010 max      119010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119010
Ave neighs/atom = 59.505
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.592578860071, Press = -2.36546790593108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3210.9013     -3210.9013     -3284.8508     -3284.8508      286.19249      286.19249      47409.784      47409.784     -264.06409     -264.06409    
     17000  -3206.1342     -3206.1342     -3282.6246     -3282.6246      296.02577      296.02577      47318.307      47318.307      104.34122      104.34122    
Loop time of 17.287 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.998 ns/day, 4.802 hours/ns, 57.847 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.099     | 17.099     | 17.099     |   0.0 | 98.91
Neigh   | 0.10767    | 0.10767    | 0.10767    |   0.0 |  0.62
Comm    | 0.0135     | 0.0135     | 0.0135     |   0.0 |  0.08
Output  | 3.223e-05  | 3.223e-05  | 3.223e-05  |   0.0 |  0.00
Modify  | 0.061788   | 0.061788   | 0.061788   |   0.0 |  0.36
Other   |            | 0.004602   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3344 ave        3344 max        3344 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119206 ave      119206 max      119206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119206
Ave neighs/atom = 59.603
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.390325776574, Press = -3.40358459223855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3206.1342     -3206.1342     -3282.6246     -3282.6246      296.02577      296.02577      47318.307      47318.307      104.34122      104.34122    
     18000  -3206.9729     -3206.9729     -3282.7082     -3282.7082      293.10357      293.10357      47043.767      47043.767      594.04987      594.04987    
Loop time of 17.2341 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.013 ns/day, 4.787 hours/ns, 58.024 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.042     | 17.042     | 17.042     |   0.0 | 98.88
Neigh   | 0.11242    | 0.11242    | 0.11242    |   0.0 |  0.65
Comm    | 0.013593   | 0.013593   | 0.013593   |   0.0 |  0.08
Output  | 2.1631e-05 | 2.1631e-05 | 2.1631e-05 |   0.0 |  0.00
Modify  | 0.061799   | 0.061799   | 0.061799   |   0.0 |  0.36
Other   |            | 0.004599   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3291 ave        3291 max        3291 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119934 ave      119934 max      119934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119934
Ave neighs/atom = 59.967
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.25963764217, Press = 1.23296861060754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3206.9729     -3206.9729     -3282.7082     -3282.7082      293.10357      293.10357      47043.767      47043.767      594.04987      594.04987    
     19000  -3207.3329     -3207.3329     -3283.2113     -3283.2113      293.6571       293.6571       47248.976      47248.976      188.11089      188.11089    
Loop time of 17.2817 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.000 ns/day, 4.800 hours/ns, 57.865 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.084     | 17.084     | 17.084     |   0.0 | 98.86
Neigh   | 0.1174     | 0.1174     | 0.1174     |   0.0 |  0.68
Comm    | 0.013632   | 0.013632   | 0.013632   |   0.0 |  0.08
Output  | 2.1921e-05 | 2.1921e-05 | 2.1921e-05 |   0.0 |  0.00
Modify  | 0.061746   | 0.061746   | 0.061746   |   0.0 |  0.36
Other   |            | 0.004558   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3314 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119636 ave      119636 max      119636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119636
Ave neighs/atom = 59.818
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.306493843464, Press = 1.01437555244582
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -3207.3329     -3207.3329     -3283.2113     -3283.2113      293.6571       293.6571       47248.976      47248.976      188.11089      188.11089    
     20000  -3202.9956     -3202.9956     -3278.7847     -3278.7847      293.31163      293.31163      47440.509      47440.509     -122.58619     -122.58619    
Loop time of 17.2904 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.997 ns/day, 4.803 hours/ns, 57.835 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.098     | 17.098     | 17.098     |   0.0 | 98.89
Neigh   | 0.112      | 0.112      | 0.112      |   0.0 |  0.65
Comm    | 0.01364    | 0.01364    | 0.01364    |   0.0 |  0.08
Output  | 2.2282e-05 | 2.2282e-05 | 2.2282e-05 |   0.0 |  0.00
Modify  | 0.061756   | 0.061756   | 0.061756   |   0.0 |  0.36
Other   |            | 0.004573   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3325 ave        3325 max        3325 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119488 ave      119488 max      119488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119488
Ave neighs/atom = 59.744
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.398950325743, Press = 0.0138191293125696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3202.9956     -3202.9956     -3278.7847     -3278.7847      293.31163      293.31163      47440.509      47440.509     -122.58619     -122.58619    
     21000  -3208.13       -3208.13       -3283.9066     -3283.9066      293.26313      293.26313      47273.848      47273.848      188.25409      188.25409    
Loop time of 17.2101 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.020 ns/day, 4.781 hours/ns, 58.106 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.023     | 17.023     | 17.023     |   0.0 | 98.91
Neigh   | 0.10708    | 0.10708    | 0.10708    |   0.0 |  0.62
Comm    | 0.013508   | 0.013508   | 0.013508   |   0.0 |  0.08
Output  | 3.3994e-05 | 3.3994e-05 | 3.3994e-05 |   0.0 |  0.00
Modify  | 0.061702   | 0.061702   | 0.061702   |   0.0 |  0.36
Other   |            | 0.004616   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3326 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119572 ave      119572 max      119572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119572
Ave neighs/atom = 59.786
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.502638769302, Press = 0.656193823717797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -3208.13       -3208.13       -3283.9066     -3283.9066      293.26313      293.26313      47273.848      47273.848      188.25409      188.25409    
     22000  -3207.482      -3207.482      -3282.6523     -3282.6523      290.91701      290.91701      47525.084      47525.084     -456.08892     -456.08892    
Loop time of 17.2701 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.003 ns/day, 4.797 hours/ns, 57.904 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.077     | 17.077     | 17.077     |   0.0 | 98.88
Neigh   | 0.1129     | 0.1129     | 0.1129     |   0.0 |  0.65
Comm    | 0.013584   | 0.013584   | 0.013584   |   0.0 |  0.08
Output  | 2.1992e-05 | 2.1992e-05 | 2.1992e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.36
Other   |            | 0.004587   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3320 ave        3320 max        3320 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119064 ave      119064 max      119064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119064
Ave neighs/atom = 59.532
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.462818151564, Press = 0.269954982709534
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3207.482      -3207.482      -3282.6523     -3282.6523      290.91701      290.91701      47525.084      47525.084     -456.08892     -456.08892    
     23000  -3204.8309     -3204.8309     -3281.4083     -3281.4083      296.36249      296.36249      47543.72       47543.72      -469.04085     -469.04085    
Loop time of 17.2787 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.000 ns/day, 4.800 hours/ns, 57.875 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.086     | 17.086     | 17.086     |   0.0 | 98.89
Neigh   | 0.11238    | 0.11238    | 0.11238    |   0.0 |  0.65
Comm    | 0.013596   | 0.013596   | 0.013596   |   0.0 |  0.08
Output  | 2.1961e-05 | 2.1961e-05 | 2.1961e-05 |   0.0 |  0.00
Modify  | 0.061778   | 0.061778   | 0.061778   |   0.0 |  0.36
Other   |            | 0.0047     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3324 ave        3324 max        3324 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118998 ave      118998 max      118998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118998
Ave neighs/atom = 59.499
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.362722900278, Press = -0.336946376928201
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3204.8309     -3204.8309     -3281.4083     -3281.4083      296.36249      296.36249      47543.72       47543.72      -469.04085     -469.04085    
     24000  -3206.6455     -3206.6455     -3282.9659     -3282.9659      295.36798      295.36798      47458.377      47458.377     -273.512       -273.512      
Loop time of 17.264 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.005 ns/day, 4.796 hours/ns, 57.924 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.072     | 17.072     | 17.072     |   0.0 | 98.89
Neigh   | 0.11119    | 0.11119    | 0.11119    |   0.0 |  0.64
Comm    | 0.013708   | 0.013708   | 0.013708   |   0.0 |  0.08
Output  | 3.1759e-05 | 3.1759e-05 | 3.1759e-05 |   0.0 |  0.00
Modify  | 0.061982   | 0.061982   | 0.061982   |   0.0 |  0.36
Other   |            | 0.004981   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3327 ave        3327 max        3327 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118992 ave      118992 max      118992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118992
Ave neighs/atom = 59.496
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.29688841066, Press = -1.14535325261933
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -3206.6455     -3206.6455     -3282.9659     -3282.9659      295.36798      295.36798      47458.377      47458.377     -273.512       -273.512      
     25000  -3207.7094     -3207.7094     -3284.5472     -3284.5472      297.37017      297.37017      47162.476      47162.476      263.80817      263.80817    
Loop time of 17.3065 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.992 ns/day, 4.807 hours/ns, 57.782 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.111     | 17.111     | 17.111     |   0.0 | 98.87
Neigh   | 0.11247    | 0.11247    | 0.11247    |   0.0 |  0.65
Comm    | 0.014181   | 0.014181   | 0.014181   |   0.0 |  0.08
Output  | 2.2643e-05 | 2.2643e-05 | 2.2643e-05 |   0.0 |  0.00
Modify  | 0.062463   | 0.062463   | 0.062463   |   0.0 |  0.36
Other   |            | 0.005844   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3335 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119640 ave      119640 max      119640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119640
Ave neighs/atom = 59.82
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.348670210232, Press = -1.03416419674075
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3207.7094     -3207.7094     -3284.5472     -3284.5472      297.37017      297.37017      47162.476      47162.476      263.80817      263.80817    
     26000  -3207.6757     -3207.6757     -3283.1791     -3283.1791      292.20622      292.20622      47177.082      47177.082      301.16708      301.16708    
Loop time of 17.3201 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.988 ns/day, 4.811 hours/ns, 57.737 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.121     | 17.121     | 17.121     |   0.0 | 98.85
Neigh   | 0.11639    | 0.11639    | 0.11639    |   0.0 |  0.67
Comm    | 0.014167   | 0.014167   | 0.014167   |   0.0 |  0.08
Output  | 2.5027e-05 | 2.5027e-05 | 2.5027e-05 |   0.0 |  0.00
Modify  | 0.06247    | 0.06247    | 0.06247    |   0.0 |  0.36
Other   |            | 0.005856   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3326 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119764 ave      119764 max      119764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119764
Ave neighs/atom = 59.882
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.385262447392, Press = 1.13878253380399
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3207.6757     -3207.6757     -3283.1791     -3283.1791      292.20622      292.20622      47177.082      47177.082      301.16708      301.16708    
     27000  -3207.0158     -3207.0158     -3284.2125     -3284.2125      298.7595       298.7595       47588.36       47588.36      -585.26069     -585.26069    
Loop time of 17.2783 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.001 ns/day, 4.800 hours/ns, 57.876 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.09      | 17.09      | 17.09      |   0.0 | 98.91
Neigh   | 0.10753    | 0.10753    | 0.10753    |   0.0 |  0.62
Comm    | 0.013669   | 0.013669   | 0.013669   |   0.0 |  0.08
Output  | 2.2542e-05 | 2.2542e-05 | 2.2542e-05 |   0.0 |  0.00
Modify  | 0.062015   | 0.062015   | 0.062015   |   0.0 |  0.36
Other   |            | 0.005113   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3315 ave        3315 max        3315 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119134 ave      119134 max      119134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119134
Ave neighs/atom = 59.567
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.492018055378, Press = 0.526394632889313
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3207.0158     -3207.0158     -3284.2125     -3284.2125      298.7595       298.7595       47588.36       47588.36      -585.26069     -585.26069    
     28000  -3207.818      -3207.818      -3283.7949     -3283.7949      294.03843      294.03843      47406.656      47406.656     -341.81793     -341.81793    
Loop time of 17.2626 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.005 ns/day, 4.795 hours/ns, 57.929 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.069     | 17.069     | 17.069     |   0.0 | 98.88
Neigh   | 0.11252    | 0.11252    | 0.11252    |   0.0 |  0.65
Comm    | 0.013729   | 0.013729   | 0.013729   |   0.0 |  0.08
Output  | 3.2872e-05 | 3.2872e-05 | 3.2872e-05 |   0.0 |  0.00
Modify  | 0.062074   | 0.062074   | 0.062074   |   0.0 |  0.36
Other   |            | 0.005126   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3300 ave        3300 max        3300 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119164 ave      119164 max      119164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119164
Ave neighs/atom = 59.582
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.544762766766, Press = -2.03569717949755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3207.818      -3207.818      -3283.7949     -3283.7949      294.03843      294.03843      47406.656      47406.656     -341.81793     -341.81793    
     29000  -3205.733      -3205.733      -3280.3848     -3280.3848      288.91026      288.91026      47238.173      47238.173      351.52336      351.52336    
Loop time of 17.2414 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.011 ns/day, 4.789 hours/ns, 58.000 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.048     | 17.048     | 17.048     |   0.0 | 98.88
Neigh   | 0.11257    | 0.11257    | 0.11257    |   0.0 |  0.65
Comm    | 0.013654   | 0.013654   | 0.013654   |   0.0 |  0.08
Output  | 2.2172e-05 | 2.2172e-05 | 2.2172e-05 |   0.0 |  0.00
Modify  | 0.061884   | 0.061884   | 0.061884   |   0.0 |  0.36
Other   |            | 0.004825   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3334 ave        3334 max        3334 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119570 ave      119570 max      119570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119570
Ave neighs/atom = 59.785
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.612435875502, Press = -1.20021350057879
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -3205.733      -3205.733      -3280.3848     -3280.3848      288.91026      288.91026      47238.173      47238.173      351.52336      351.52336    
     30000  -3205.7662     -3205.7662     -3282.5914     -3282.5914      297.32138      297.32138      47233.769      47233.769      275.97776      275.97776    
Loop time of 17.2726 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.002 ns/day, 4.798 hours/ns, 57.895 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.086     | 17.086     | 17.086     |   0.0 | 98.92
Neigh   | 0.10693    | 0.10693    | 0.10693    |   0.0 |  0.62
Comm    | 0.013534   | 0.013534   | 0.013534   |   0.0 |  0.08
Output  | 2.1731e-05 | 2.1731e-05 | 2.1731e-05 |   0.0 |  0.00
Modify  | 0.061786   | 0.061786   | 0.061786   |   0.0 |  0.36
Other   |            | 0.004723   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3319 ave        3319 max        3319 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119524 ave      119524 max      119524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119524
Ave neighs/atom = 59.762
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.526479004112, Press = 0.365402891141677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -3205.7662     -3205.7662     -3282.5914     -3282.5914      297.32138      297.32138      47233.769      47233.769      275.97776      275.97776    
     31000  -3210.0189     -3210.0189     -3284.0851     -3284.0851      286.64379      286.64379      47333.023      47333.023     -58.757184     -58.757184    
Loop time of 17.236 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.013 ns/day, 4.788 hours/ns, 58.018 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.044     | 17.044     | 17.044     |   0.0 | 98.88
Neigh   | 0.11194    | 0.11194    | 0.11194    |   0.0 |  0.65
Comm    | 0.01362    | 0.01362    | 0.01362    |   0.0 |  0.08
Output  | 3.1188e-05 | 3.1188e-05 | 3.1188e-05 |   0.0 |  0.00
Modify  | 0.061894   | 0.061894   | 0.061894   |   0.0 |  0.36
Other   |            | 0.004722   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3330 ave        3330 max        3330 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119464 ave      119464 max      119464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119464
Ave neighs/atom = 59.732
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.476650702997, Press = 0.663745250123938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -3210.0189     -3210.0189     -3284.0851     -3284.0851      286.64379      286.64379      47333.023      47333.023     -58.757184     -58.757184    
     32000  -3208.0736     -3208.0736     -3283.4151     -3283.4151      291.57963      291.57963      47408.836      47408.836     -149.21708     -149.21708    
Loop time of 17.3873 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.969 ns/day, 4.830 hours/ns, 57.513 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.2       | 17.2       | 17.2       |   0.0 | 98.93
Neigh   | 0.10687    | 0.10687    | 0.10687    |   0.0 |  0.61
Comm    | 0.01354    | 0.01354    | 0.01354    |   0.0 |  0.08
Output  | 2.3183e-05 | 2.3183e-05 | 2.3183e-05 |   0.0 |  0.00
Modify  | 0.061752   | 0.061752   | 0.061752   |   0.0 |  0.36
Other   |            | 0.004606   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3297 ave        3297 max        3297 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119188 ave      119188 max      119188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119188
Ave neighs/atom = 59.594
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.502390570184, Press = -0.324744977918588
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -3208.0736     -3208.0736     -3283.4151     -3283.4151      291.57963      291.57963      47408.836      47408.836     -149.21708     -149.21708    
     33000  -3205.03       -3205.03       -3281.5399     -3281.5399      296.10129      296.10129      47401.469      47401.469     -61.235711     -61.235711    
Loop time of 17.2768 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.001 ns/day, 4.799 hours/ns, 57.881 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.089     | 17.089     | 17.089     |   0.0 | 98.91
Neigh   | 0.10799    | 0.10799    | 0.10799    |   0.0 |  0.63
Comm    | 0.013517   | 0.013517   | 0.013517   |   0.0 |  0.08
Output  | 2.2041e-05 | 2.2041e-05 | 2.2041e-05 |   0.0 |  0.00
Modify  | 0.061861   | 0.061861   | 0.061861   |   0.0 |  0.36
Other   |            | 0.004733   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3321 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119248 ave      119248 max      119248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119248
Ave neighs/atom = 59.624
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.548878049936, Press = -0.810209182310362
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -3205.03       -3205.03       -3281.5399     -3281.5399      296.10129      296.10129      47401.469      47401.469     -61.235711     -61.235711    
     34000  -3206.0176     -3206.0176     -3282.2005     -3282.2005      294.83575      294.83575      47308.356      47308.356      184.11278      184.11278    
Loop time of 17.2747 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.002 ns/day, 4.799 hours/ns, 57.888 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.082     | 17.082     | 17.082     |   0.0 | 98.89
Neigh   | 0.11244    | 0.11244    | 0.11244    |   0.0 |  0.65
Comm    | 0.013552   | 0.013552   | 0.013552   |   0.0 |  0.08
Output  | 2.2172e-05 | 2.2172e-05 | 2.2172e-05 |   0.0 |  0.00
Modify  | 0.061774   | 0.061774   | 0.061774   |   0.0 |  0.36
Other   |            | 0.004633   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3319 ave        3319 max        3319 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119382 ave      119382 max      119382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119382
Ave neighs/atom = 59.691
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.531158875449, Press = 0.215239400593837
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -3206.0176     -3206.0176     -3282.2005     -3282.2005      294.83575      294.83575      47308.356      47308.356      184.11278      184.11278    
     35000  -3208.9911     -3208.9911     -3283.9292     -3283.9292      290.01805      290.01805      47340.805      47340.805     -97.25009      -97.25009     
Loop time of 17.3162 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.990 ns/day, 4.810 hours/ns, 57.750 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.129     | 17.129     | 17.129     |   0.0 | 98.92
Neigh   | 0.10733    | 0.10733    | 0.10733    |   0.0 |  0.62
Comm    | 0.013562   | 0.013562   | 0.013562   |   0.0 |  0.08
Output  | 3.2841e-05 | 3.2841e-05 | 3.2841e-05 |   0.0 |  0.00
Modify  | 0.061796   | 0.061796   | 0.061796   |   0.0 |  0.36
Other   |            | 0.004632   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3321 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119256 ave      119256 max      119256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119256
Ave neighs/atom = 59.628
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.590775920558, Press = -0.456098028718074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -3208.9911     -3208.9911     -3283.9292     -3283.9292      290.01805      290.01805      47340.805      47340.805     -97.25009      -97.25009     
     36000  -3202.4885     -3202.4885     -3280.915      -3280.915       303.51871      303.51871      47314.129      47314.129      206.87818      206.87818    
Loop time of 17.3044 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.993 ns/day, 4.807 hours/ns, 57.789 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.117     | 17.117     | 17.117     |   0.0 | 98.91
Neigh   | 0.10798    | 0.10798    | 0.10798    |   0.0 |  0.62
Comm    | 0.013554   | 0.013554   | 0.013554   |   0.0 |  0.08
Output  | 2.1851e-05 | 2.1851e-05 | 2.1851e-05 |   0.0 |  0.00
Modify  | 0.061691   | 0.061691   | 0.061691   |   0.0 |  0.36
Other   |            | 0.004604   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3317 ave        3317 max        3317 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119372 ave      119372 max      119372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119372
Ave neighs/atom = 59.686
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.602797131431, Press = -1.27661202391147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -3202.4885     -3202.4885     -3280.915      -3280.915       303.51871      303.51871      47314.129      47314.129      206.87818      206.87818    
     37000  -3205.342      -3205.342      -3281.2819     -3281.2819      293.89529      293.89529      46847.069      46847.069      1234.0408      1234.0408    
Loop time of 17.2423 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.011 ns/day, 4.790 hours/ns, 57.997 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.05      | 17.05      | 17.05      |   0.0 | 98.89
Neigh   | 0.11239    | 0.11239    | 0.11239    |   0.0 |  0.65
Comm    | 0.013559   | 0.013559   | 0.013559   |   0.0 |  0.08
Output  | 2.1721e-05 | 2.1721e-05 | 2.1721e-05 |   0.0 |  0.00
Modify  | 0.06169    | 0.06169    | 0.06169    |   0.0 |  0.36
Other   |            | 0.004579   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3320 ave        3320 max        3320 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120200 ave      120200 max      120200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120200
Ave neighs/atom = 60.1
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.628351361851, Press = 0.0835271718990657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -3205.342      -3205.342      -3281.2819     -3281.2819      293.89529      293.89529      46847.069      46847.069      1234.0408      1234.0408    
     38000  -3208.8039     -3208.8039     -3283.1324     -3283.1324      287.65887      287.65887      47357.636      47357.636     -120.40362     -120.40362    
Loop time of 17.3365 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.984 ns/day, 4.816 hours/ns, 57.682 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.143     | 17.143     | 17.143     |   0.0 | 98.88
Neigh   | 0.11288    | 0.11288    | 0.11288    |   0.0 |  0.65
Comm    | 0.013924   | 0.013924   | 0.013924   |   0.0 |  0.08
Output  | 4.5215e-05 | 4.5215e-05 | 4.5215e-05 |   0.0 |  0.00
Modify  | 0.062101   | 0.062101   | 0.062101   |   0.0 |  0.36
Other   |            | 0.004835   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3353 ave        3353 max        3353 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119594 ave      119594 max      119594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119594
Ave neighs/atom = 59.797
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.619571810115, Press = 1.00535785180301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -3208.8039     -3208.8039     -3283.1324     -3283.1324      287.65887      287.65887      47357.636      47357.636     -120.40362     -120.40362    
     39000  -3206.6398     -3206.6398     -3283.6668     -3283.6668      298.10247      298.10247      47418.638      47418.638     -142.39161     -142.39161    
Loop time of 17.3044 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.993 ns/day, 4.807 hours/ns, 57.789 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.111     | 17.111     | 17.111     |   0.0 | 98.88
Neigh   | 0.1126     | 0.1126     | 0.1126     |   0.0 |  0.65
Comm    | 0.013914   | 0.013914   | 0.013914   |   0.0 |  0.08
Output  | 6.1906e-05 | 6.1906e-05 | 6.1906e-05 |   0.0 |  0.00
Modify  | 0.06205    | 0.06205    | 0.06205    |   0.0 |  0.36
Other   |            | 0.004813   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3349 ave        3349 max        3349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119018 ave      119018 max      119018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119018
Ave neighs/atom = 59.509
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.608953846932, Press = -0.13284212019635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3206.6398     -3206.6398     -3283.6668     -3283.6668      298.10247      298.10247      47418.638      47418.638     -142.39161     -142.39161    
     40000  -3205.1315     -3205.1315     -3281.0788     -3281.0788      293.92367      293.92367      47385.276      47385.276     -54.099667     -54.099667    
Loop time of 17.3016 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.994 ns/day, 4.806 hours/ns, 57.798 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.113     | 17.113     | 17.113     |   0.0 | 98.91
Neigh   | 0.10821    | 0.10821    | 0.10821    |   0.0 |  0.63
Comm    | 0.013854   | 0.013854   | 0.013854   |   0.0 |  0.08
Output  | 3.4525e-05 | 3.4525e-05 | 3.4525e-05 |   0.0 |  0.00
Modify  | 0.06198    | 0.06198    | 0.06198    |   0.0 |  0.36
Other   |            | 0.004811   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3368 ave        3368 max        3368 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119264 ave      119264 max      119264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119264
Ave neighs/atom = 59.632
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.5987848536, Press = -0.165522245375786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -3205.1315     -3205.1315     -3281.0788     -3281.0788      293.92367      293.92367      47385.276      47385.276     -54.099667     -54.099667    
     41000  -3206.1295     -3206.1295     -3283.322      -3283.322       298.74316      298.74316      47248.413      47248.413      167.12953      167.12953    
Loop time of 17.3264 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.987 ns/day, 4.813 hours/ns, 57.715 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.138     | 17.138     | 17.138     |   0.0 | 98.91
Neigh   | 0.10784    | 0.10784    | 0.10784    |   0.0 |  0.62
Comm    | 0.013826   | 0.013826   | 0.013826   |   0.0 |  0.08
Output  | 2.2923e-05 | 2.2923e-05 | 2.2923e-05 |   0.0 |  0.00
Modify  | 0.062003   | 0.062003   | 0.062003   |   0.0 |  0.36
Other   |            | 0.004784   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3335 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119674 ave      119674 max      119674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119674
Ave neighs/atom = 59.837
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.59677326393, Press = 0.348198694599278
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -3206.1295     -3206.1295     -3283.322      -3283.322       298.74316      298.74316      47248.413      47248.413      167.12953      167.12953    
     42000  -3210.6384     -3210.6384     -3284.6117     -3284.6117      286.28435      286.28435      47389.637      47389.637     -312.59926     -312.59926    
Loop time of 17.3769 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.972 ns/day, 4.827 hours/ns, 57.548 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.183     | 17.183     | 17.183     |   0.0 | 98.89
Neigh   | 0.11259    | 0.11259    | 0.11259    |   0.0 |  0.65
Comm    | 0.013947   | 0.013947   | 0.013947   |   0.0 |  0.08
Output  | 6.933e-05  | 6.933e-05  | 6.933e-05  |   0.0 |  0.00
Modify  | 0.062071   | 0.062071   | 0.062071   |   0.0 |  0.36
Other   |            | 0.004807   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3364 ave        3364 max        3364 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119342 ave      119342 max      119342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119342
Ave neighs/atom = 59.671
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.584609775318, Press = 1.2151752635509
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -3210.6384     -3210.6384     -3284.6117     -3284.6117      286.28435      286.28435      47389.637      47389.637     -312.59926     -312.59926    
     43000  -3208.0128     -3208.0128     -3280.9724     -3280.9724      282.3611       282.3611       47561.833      47561.833     -634.50905     -634.50905    
Loop time of 17.3121 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.991 ns/day, 4.809 hours/ns, 57.763 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.119     | 17.119     | 17.119     |   0.0 | 98.88
Neigh   | 0.11275    | 0.11275    | 0.11275    |   0.0 |  0.65
Comm    | 0.013862   | 0.013862   | 0.013862   |   0.0 |  0.08
Output  | 2.3093e-05 | 2.3093e-05 | 2.3093e-05 |   0.0 |  0.00
Modify  | 0.061962   | 0.061962   | 0.061962   |   0.0 |  0.36
Other   |            | 0.004761   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3342 ave        3342 max        3342 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118834 ave      118834 max      118834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118834
Ave neighs/atom = 59.417
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.535475617296, Press = -0.0898952531843685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -3208.0128     -3208.0128     -3280.9724     -3280.9724      282.3611       282.3611       47561.833      47561.833     -634.50905     -634.50905    
     44000  -3204.5863     -3204.5863     -3280.2579     -3280.2579      292.85705      292.85705      47355.693      47355.693     -110.11247     -110.11247    
Loop time of 17.3078 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.992 ns/day, 4.808 hours/ns, 57.778 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.115     | 17.115     | 17.115     |   0.0 | 98.88
Neigh   | 0.11247    | 0.11247    | 0.11247    |   0.0 |  0.65
Comm    | 0.013901   | 0.013901   | 0.013901   |   0.0 |  0.08
Output  | 2.3795e-05 | 2.3795e-05 | 2.3795e-05 |   0.0 |  0.00
Modify  | 0.062039   | 0.062039   | 0.062039   |   0.0 |  0.36
Other   |            | 0.004777   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3324 ave        3324 max        3324 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119074 ave      119074 max      119074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119074
Ave neighs/atom = 59.537
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.563263494939, Press = -0.875654103276463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -3204.5863     -3204.5863     -3280.2579     -3280.2579      292.85705      292.85705      47355.693      47355.693     -110.11247     -110.11247    
     45000  -3205.156      -3205.156      -3282.2336     -3282.2336      298.29835      298.29835      47217.438      47217.438      207.68407      207.68407    
Loop time of 17.2892 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.997 ns/day, 4.803 hours/ns, 57.840 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.101     | 17.101     | 17.101     |   0.0 | 98.91
Neigh   | 0.10734    | 0.10734    | 0.10734    |   0.0 |  0.62
Comm    | 0.013807   | 0.013807   | 0.013807   |   0.0 |  0.08
Output  | 3.3593e-05 | 3.3593e-05 | 3.3593e-05 |   0.0 |  0.00
Modify  | 0.062069   | 0.062069   | 0.062069   |   0.0 |  0.36
Other   |            | 0.00482    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3351 ave        3351 max        3351 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119608 ave      119608 max      119608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119608
Ave neighs/atom = 59.804
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.531337756838, Press = 0.0912055858109599
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -3205.156      -3205.156      -3282.2336     -3282.2336      298.29835      298.29835      47217.438      47217.438      207.68407      207.68407    
     46000  -3205.9838     -3205.9838     -3282.6679     -3282.6679      296.77538      296.77538      47351.801      47351.801     -117.96294     -117.96294    
Loop time of 17.2958 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.995 ns/day, 4.804 hours/ns, 57.818 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.103     | 17.103     | 17.103     |   0.0 | 98.88
Neigh   | 0.11233    | 0.11233    | 0.11233    |   0.0 |  0.65
Comm    | 0.013885   | 0.013885   | 0.013885   |   0.0 |  0.08
Output  | 2.4346e-05 | 2.4346e-05 | 2.4346e-05 |   0.0 |  0.00
Modify  | 0.061965   | 0.061965   | 0.061965   |   0.0 |  0.36
Other   |            | 0.004785   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3351 ave        3351 max        3351 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119474 ave      119474 max      119474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119474
Ave neighs/atom = 59.737
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.497039562981, Press = 0.134644622043245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -3205.9838     -3205.9838     -3282.6679     -3282.6679      296.77538      296.77538      47351.801      47351.801     -117.96294     -117.96294    
     47000  -3210.3012     -3210.3012     -3285.1061     -3285.1061      289.5026       289.5026       47276.009      47276.009      88.441055      88.441055    
Loop time of 17.2593 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.006 ns/day, 4.794 hours/ns, 57.940 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.065     | 17.065     | 17.065     |   0.0 | 98.87
Neigh   | 0.11369    | 0.11369    | 0.11369    |   0.0 |  0.66
Comm    | 0.013859   | 0.013859   | 0.013859   |   0.0 |  0.08
Output  | 2.2712e-05 | 2.2712e-05 | 2.2712e-05 |   0.0 |  0.00
Modify  | 0.061972   | 0.061972   | 0.061972   |   0.0 |  0.36
Other   |            | 0.004791   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3355 ave        3355 max        3355 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119398 ave      119398 max      119398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119398
Ave neighs/atom = 59.699
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.478709344583, Press = -0.0681760826848965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -3210.3012     -3210.3012     -3285.1061     -3285.1061      289.5026       289.5026       47276.009      47276.009      88.441055      88.441055    
     48000  -3206.5881     -3206.5881     -3282.7291     -3282.7291      294.67383      294.67383      47499.43       47499.43      -326.52545     -326.52545    
Loop time of 17.2952 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.996 ns/day, 4.804 hours/ns, 57.820 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.106     | 17.106     | 17.106     |   0.0 | 98.90
Neigh   | 0.10881    | 0.10881    | 0.10881    |   0.0 |  0.63
Comm    | 0.013811   | 0.013811   | 0.013811   |   0.0 |  0.08
Output  | 2.7282e-05 | 2.7282e-05 | 2.7282e-05 |   0.0 |  0.00
Modify  | 0.062056   | 0.062056   | 0.062056   |   0.0 |  0.36
Other   |            | 0.004795   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3295 ave        3295 max        3295 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119144 ave      119144 max      119144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119144
Ave neighs/atom = 59.572
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.462346479894, Press = -0.243258292398443
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -3206.5881     -3206.5881     -3282.7291     -3282.7291      294.67383      294.67383      47499.43       47499.43      -326.52545     -326.52545    
     49000  -3206.3032     -3206.3032     -3281.3043     -3281.3043      290.26203      290.26203      47224.57       47224.57       123.13015      123.13015    
Loop time of 17.2978 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.995 ns/day, 4.805 hours/ns, 57.811 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.103     | 17.103     | 17.103     |   0.0 | 98.88
Neigh   | 0.11345    | 0.11345    | 0.11345    |   0.0 |  0.66
Comm    | 0.013965   | 0.013965   | 0.013965   |   0.0 |  0.08
Output  | 3.6659e-05 | 3.6659e-05 | 3.6659e-05 |   0.0 |  0.00
Modify  | 0.062123   | 0.062123   | 0.062123   |   0.0 |  0.36
Other   |            | 0.004801   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3331 ave        3331 max        3331 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119648 ave      119648 max      119648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119648
Ave neighs/atom = 59.824
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.472229637915, Press = -0.903792256136881
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -3206.3032     -3206.3032     -3281.3043     -3281.3043      290.26203      290.26203      47224.57       47224.57       123.13015      123.13015    
     50000  -3202.7832     -3202.7832     -3280.1708     -3280.1708      299.49798      299.49798      47191.788      47191.788      411.43725      411.43725    
Loop time of 17.3253 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.987 ns/day, 4.813 hours/ns, 57.719 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.132     | 17.132     | 17.132     |   0.0 | 98.88
Neigh   | 0.11269    | 0.11269    | 0.11269    |   0.0 |  0.65
Comm    | 0.013941   | 0.013941   | 0.013941   |   0.0 |  0.08
Output  | 2.2493e-05 | 2.2493e-05 | 2.2493e-05 |   0.0 |  0.00
Modify  | 0.062      | 0.062      | 0.062      |   0.0 |  0.36
Other   |            | 0.004762   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3349 ave        3349 max        3349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119602 ave      119602 max      119602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119602
Ave neighs/atom = 59.801
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.512235197673, Press = 0.32674183571324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -3202.7832     -3202.7832     -3280.1708     -3280.1708      299.49798      299.49798      47191.788      47191.788      411.43725      411.43725    
     51000  -3208.5553     -3208.5553     -3282.9765     -3282.9765      288.01755      288.01755      47548.899      47548.899     -522.93877     -522.93877    
Loop time of 17.3671 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.975 ns/day, 4.824 hours/ns, 57.580 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.178     | 17.178     | 17.178     |   0.0 | 98.91
Neigh   | 0.10792    | 0.10792    | 0.10792    |   0.0 |  0.62
Comm    | 0.013846   | 0.013846   | 0.013846   |   0.0 |  0.08
Output  | 2.3053e-05 | 2.3053e-05 | 2.3053e-05 |   0.0 |  0.00
Modify  | 0.06216    | 0.06216    | 0.06216    |   0.0 |  0.36
Other   |            | 0.004795   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3296 ave        3296 max        3296 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119188 ave      119188 max      119188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119188
Ave neighs/atom = 59.594
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.497843383785, Press = -0.0245805664139467
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -3208.5553     -3208.5553     -3282.9765     -3282.9765      288.01755      288.01755      47548.899      47548.899     -522.93877     -522.93877    
     52000  -3206.2795     -3206.2795     -3281.7713     -3281.7713      292.16109      292.16109      47419.357      47419.357     -253.3142      -253.3142     
Loop time of 17.3652 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.975 ns/day, 4.824 hours/ns, 57.586 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.17      | 17.17      | 17.17      |   0.0 | 98.88
Neigh   | 0.114      | 0.114      | 0.114      |   0.0 |  0.66
Comm    | 0.013938   | 0.013938   | 0.013938   |   0.0 |  0.08
Output  | 3.1339e-05 | 3.1339e-05 | 3.1339e-05 |   0.0 |  0.00
Modify  | 0.062266   | 0.062266   | 0.062266   |   0.0 |  0.36
Other   |            | 0.004805   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3314 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119036 ave      119036 max      119036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119036
Ave neighs/atom = 59.518
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.461187942494, Press = -1.3459827518891
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -3206.2795     -3206.2795     -3281.7713     -3281.7713      292.16109      292.16109      47419.357      47419.357     -253.3142      -253.3142     
     53000  -3207.2373     -3207.2373     -3283.1482     -3283.1482      293.783        293.783        47147.588      47147.588      332.28496      332.28496    
Loop time of 17.4129 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.962 ns/day, 4.837 hours/ns, 57.429 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.219     | 17.219     | 17.219     |   0.0 | 98.89
Neigh   | 0.11279    | 0.11279    | 0.11279    |   0.0 |  0.65
Comm    | 0.013897   | 0.013897   | 0.013897   |   0.0 |  0.08
Output  | 2.3464e-05 | 2.3464e-05 | 2.3464e-05 |   0.0 |  0.00
Modify  | 0.06231    | 0.06231    | 0.06231    |   0.0 |  0.36
Other   |            | 0.004783   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3355 ave        3355 max        3355 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119588 ave      119588 max      119588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119588
Ave neighs/atom = 59.794
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.452266211052, Press = -0.478260745128878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -3207.2373     -3207.2373     -3283.1482     -3283.1482      293.783        293.783        47147.588      47147.588      332.28496      332.28496    
     54000  -3203.6014     -3203.6014     -3283.7732     -3283.7732      310.27339      310.27339      47239.512      47239.512      268.33473      268.33473    
Loop time of 17.33 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.986 ns/day, 4.814 hours/ns, 57.703 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.136     | 17.136     | 17.136     |   0.0 | 98.88
Neigh   | 0.11334    | 0.11334    | 0.11334    |   0.0 |  0.65
Comm    | 0.013883   | 0.013883   | 0.013883   |   0.0 |  0.08
Output  | 2.4146e-05 | 2.4146e-05 | 2.4146e-05 |   0.0 |  0.00
Modify  | 0.062064   | 0.062064   | 0.062064   |   0.0 |  0.36
Other   |            | 0.004754   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3334 ave        3334 max        3334 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119684 ave      119684 max      119684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119684
Ave neighs/atom = 59.842
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.446590177061, Press = 0.348778878131722
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -3203.6014     -3203.6014     -3283.7732     -3283.7732      310.27339      310.27339      47239.512      47239.512      268.33473      268.33473    
     55000  -3206.9138     -3206.9138     -3282.0865     -3282.0865      290.92618      290.92618      47397.848      47397.848     -95.376935     -95.376935    
Loop time of 17.3144 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.990 ns/day, 4.810 hours/ns, 57.756 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.12      | 17.12      | 17.12      |   0.0 | 98.88
Neigh   | 0.1136     | 0.1136     | 0.1136     |   0.0 |  0.66
Comm    | 0.013874   | 0.013874   | 0.013874   |   0.0 |  0.08
Output  | 2.3163e-05 | 2.3163e-05 | 2.3163e-05 |   0.0 |  0.00
Modify  | 0.062126   | 0.062126   | 0.062126   |   0.0 |  0.36
Other   |            | 0.004759   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3310 ave        3310 max        3310 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119148 ave      119148 max      119148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119148
Ave neighs/atom = 59.574
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.437852043784, Press = 0.156237791456551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -3206.9138     -3206.9138     -3282.0865     -3282.0865      290.92618      290.92618      47397.848      47397.848     -95.376935     -95.376935    
     56000  -3205.4581     -3205.4581     -3281.9137     -3281.9137      295.89113      295.89113      47377.025      47377.025     -135.3264      -135.3264     
Loop time of 17.3197 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.989 ns/day, 4.811 hours/ns, 57.738 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.126     | 17.126     | 17.126     |   0.0 | 98.88
Neigh   | 0.1126     | 0.1126     | 0.1126     |   0.0 |  0.65
Comm    | 0.013875   | 0.013875   | 0.013875   |   0.0 |  0.08
Output  | 3.5115e-05 | 3.5115e-05 | 3.5115e-05 |   0.0 |  0.00
Modify  | 0.062018   | 0.062018   | 0.062018   |   0.0 |  0.36
Other   |            | 0.004774   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3324 ave        3324 max        3324 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119232 ave      119232 max      119232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119232
Ave neighs/atom = 59.616
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.410346151204, Press = -0.389497831120276
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -3205.4581     -3205.4581     -3281.9137     -3281.9137      295.89113      295.89113      47377.025      47377.025     -135.3264      -135.3264     
     57000  -3205.6553     -3205.6553     -3282.1726     -3282.1726      296.12991      296.12991      47074.947      47074.947      618.45123      618.45123    
Loop time of 17.3057 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.993 ns/day, 4.807 hours/ns, 57.785 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.112     | 17.112     | 17.112     |   0.0 | 98.88
Neigh   | 0.11306    | 0.11306    | 0.11306    |   0.0 |  0.65
Comm    | 0.013885   | 0.013885   | 0.013885   |   0.0 |  0.08
Output  | 2.2943e-05 | 2.2943e-05 | 2.2943e-05 |   0.0 |  0.00
Modify  | 0.061976   | 0.061976   | 0.061976   |   0.0 |  0.36
Other   |            | 0.004779   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3358 ave        3358 max        3358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120076 ave      120076 max      120076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120076
Ave neighs/atom = 60.038
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.399733052289, Press = -0.423969081455407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -3205.6553     -3205.6553     -3282.1726     -3282.1726      296.12991      296.12991      47074.947      47074.947      618.45123      618.45123    
     58000  -3203.7936     -3203.7936     -3281.9768     -3281.9768      302.57709      302.57709      47196.776      47196.776      310.89741      310.89741    
Loop time of 17.3053 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.993 ns/day, 4.807 hours/ns, 57.786 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.116     | 17.116     | 17.116     |   0.0 | 98.91
Neigh   | 0.1081     | 0.1081     | 0.1081     |   0.0 |  0.62
Comm    | 0.013885   | 0.013885   | 0.013885   |   0.0 |  0.08
Output  | 2.4706e-05 | 2.4706e-05 | 2.4706e-05 |   0.0 |  0.00
Modify  | 0.062004   | 0.062004   | 0.062004   |   0.0 |  0.36
Other   |            | 0.004794   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3308 ave        3308 max        3308 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119794 ave      119794 max      119794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119794
Ave neighs/atom = 59.897
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.383723000971, Press = 0.579500078735017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -3203.7936     -3203.7936     -3281.9768     -3281.9768      302.57709      302.57709      47196.776      47196.776      310.89741      310.89741    
     59000  -3204.7395     -3204.7395     -3281.7485     -3281.7485      298.0329       298.0329       47437.911      47437.911     -252.7653      -252.7653     
Loop time of 17.3111 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.991 ns/day, 4.809 hours/ns, 57.766 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.117     | 17.117     | 17.117     |   0.0 | 98.88
Neigh   | 0.11288    | 0.11288    | 0.11288    |   0.0 |  0.65
Comm    | 0.013909   | 0.013909   | 0.013909   |   0.0 |  0.08
Output  | 3.2471e-05 | 3.2471e-05 | 3.2471e-05 |   0.0 |  0.00
Modify  | 0.062002   | 0.062002   | 0.062002   |   0.0 |  0.36
Other   |            | 0.004779   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3361 ave        3361 max        3361 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119330 ave      119330 max      119330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119330
Ave neighs/atom = 59.665
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.390598998213, Press = 0.489247664288341
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -3204.7395     -3204.7395     -3281.7485     -3281.7485      298.0329       298.0329       47437.911      47437.911     -252.7653      -252.7653     
     60000  -3210.7677     -3210.7677     -3284.6757     -3284.6757      286.03169      286.03169      47325.006      47325.006     -106.45202     -106.45202    
Loop time of 17.2865 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.998 ns/day, 4.802 hours/ns, 57.849 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.098     | 17.098     | 17.098     |   0.0 | 98.91
Neigh   | 0.10808    | 0.10808    | 0.10808    |   0.0 |  0.63
Comm    | 0.013757   | 0.013757   | 0.013757   |   0.0 |  0.08
Output  | 2.3244e-05 | 2.3244e-05 | 2.3244e-05 |   0.0 |  0.00
Modify  | 0.061925   | 0.061925   | 0.061925   |   0.0 |  0.36
Other   |            | 0.004774   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3301 ave        3301 max        3301 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119224 ave      119224 max      119224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119224
Ave neighs/atom = 59.612
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.424805819463, Press = -0.336182786334642
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -3210.7677     -3210.7677     -3284.6757     -3284.6757      286.03169      286.03169      47325.006      47325.006     -106.45202     -106.45202    
     61000  -3204.1109     -3204.1109     -3281.7318     -3281.7318      300.401        300.401        47227.844      47227.844      319.72626      319.72626    
Loop time of 17.3333 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.985 ns/day, 4.815 hours/ns, 57.693 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.145     | 17.145     | 17.145     |   0.0 | 98.91
Neigh   | 0.10791    | 0.10791    | 0.10791    |   0.0 |  0.62
Comm    | 0.013819   | 0.013819   | 0.013819   |   0.0 |  0.08
Output  | 2.3925e-05 | 2.3925e-05 | 2.3925e-05 |   0.0 |  0.00
Modify  | 0.061978   | 0.061978   | 0.061978   |   0.0 |  0.36
Other   |            | 0.00476    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3340 ave        3340 max        3340 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119334 ave      119334 max      119334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119334
Ave neighs/atom = 59.667
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.412430827875, Press = -0.330275045781299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -3204.1109     -3204.1109     -3281.7318     -3281.7318      300.401        300.401        47227.844      47227.844      319.72626      319.72626    
     62000  -3207.1286     -3207.1286     -3282.5653     -3282.5653      291.94771      291.94771      47178.11       47178.11       290.14152      290.14152    
Loop time of 17.33 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.986 ns/day, 4.814 hours/ns, 57.703 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.142     | 17.142     | 17.142     |   0.0 | 98.91
Neigh   | 0.10751    | 0.10751    | 0.10751    |   0.0 |  0.62
Comm    | 0.01389    | 0.01389    | 0.01389    |   0.0 |  0.08
Output  | 3.0217e-05 | 3.0217e-05 | 3.0217e-05 |   0.0 |  0.00
Modify  | 0.061979   | 0.061979   | 0.061979   |   0.0 |  0.36
Other   |            | 0.004795   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3333 ave        3333 max        3333 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119918 ave      119918 max      119918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119918
Ave neighs/atom = 59.959
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.409556459023, Press = 0.0362781508488056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -3207.1286     -3207.1286     -3282.5653     -3282.5653      291.94771      291.94771      47178.11       47178.11       290.14152      290.14152    
     63000  -3205.5187     -3205.5187     -3282.3828     -3282.3828      297.47206      297.47206      47461.39       47461.39      -151.40446     -151.40446    
Loop time of 17.3121 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.991 ns/day, 4.809 hours/ns, 57.763 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.119     | 17.119     | 17.119     |   0.0 | 98.89
Neigh   | 0.1122     | 0.1122     | 0.1122     |   0.0 |  0.65
Comm    | 0.013842   | 0.013842   | 0.013842   |   0.0 |  0.08
Output  | 2.3834e-05 | 2.3834e-05 | 2.3834e-05 |   0.0 |  0.00
Modify  | 0.061942   | 0.061942   | 0.061942   |   0.0 |  0.36
Other   |            | 0.00476    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3348 ave        3348 max        3348 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119276 ave      119276 max      119276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119276
Ave neighs/atom = 59.638
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.381714932896, Press = 0.77721577596726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -3205.5187     -3205.5187     -3282.3828     -3282.3828      297.47206      297.47206      47461.39       47461.39      -151.40446     -151.40446    
     64000  -3209.5385     -3209.5385     -3285.0531     -3285.0531      292.24949      292.24949      47627.244      47627.244     -794.39932     -794.39932    
Loop time of 17.3104 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.991 ns/day, 4.808 hours/ns, 57.769 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.117     | 17.117     | 17.117     |   0.0 | 98.89
Neigh   | 0.11247    | 0.11247    | 0.11247    |   0.0 |  0.65
Comm    | 0.01378    | 0.01378    | 0.01378    |   0.0 |  0.08
Output  | 2.2993e-05 | 2.2993e-05 | 2.2993e-05 |   0.0 |  0.00
Modify  | 0.061892   | 0.061892   | 0.061892   |   0.0 |  0.36
Other   |            | 0.004753   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3320 ave        3320 max        3320 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119038 ave      119038 max      119038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119038
Ave neighs/atom = 59.519
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.355631430899, Press = 0.0348730465881587
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -3209.5385     -3209.5385     -3285.0531     -3285.0531      292.24949      292.24949      47627.244      47627.244     -794.39932     -794.39932    
     65000  -3206.6843     -3206.6843     -3283.8063     -3283.8063      298.46999      298.46999      47219.739      47219.739      346.75065      346.75065    
Loop time of 17.3016 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.994 ns/day, 4.806 hours/ns, 57.798 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.113     | 17.113     | 17.113     |   0.0 | 98.91
Neigh   | 0.108      | 0.108      | 0.108      |   0.0 |  0.62
Comm    | 0.013737   | 0.013737   | 0.013737   |   0.0 |  0.08
Output  | 2.4787e-05 | 2.4787e-05 | 2.4787e-05 |   0.0 |  0.00
Modify  | 0.061914   | 0.061914   | 0.061914   |   0.0 |  0.36
Other   |            | 0.004758   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3365 ave        3365 max        3365 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119588 ave      119588 max      119588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119588
Ave neighs/atom = 59.794
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.362211387111, Press = -0.280518953176061
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -3206.6843     -3206.6843     -3283.8063     -3283.8063      298.46999      298.46999      47219.739      47219.739      346.75065      346.75065    
     66000  -3207.7358     -3207.7358     -3282.1805     -3282.1805      288.10848      288.10848      47227.985      47227.985      203.01393      203.01393    
Loop time of 17.3124 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.991 ns/day, 4.809 hours/ns, 57.762 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.119     | 17.119     | 17.119     |   0.0 | 98.88
Neigh   | 0.11302    | 0.11302    | 0.11302    |   0.0 |  0.65
Comm    | 0.013792   | 0.013792   | 0.013792   |   0.0 |  0.08
Output  | 3.8883e-05 | 3.8883e-05 | 3.8883e-05 |   0.0 |  0.00
Modify  | 0.062032   | 0.062032   | 0.062032   |   0.0 |  0.36
Other   |            | 0.004766   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3377 ave        3377 max        3377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119442 ave      119442 max      119442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119442
Ave neighs/atom = 59.721
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.395288113434, Press = 0.284557554840347
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -3207.7358     -3207.7358     -3282.1805     -3282.1805      288.10848      288.10848      47227.985      47227.985      203.01393      203.01393    
     67000  -3204.4407     -3204.4407     -3281.2078     -3281.2078      297.09675      297.09675      47309.489      47309.489      185.93732      185.93732    
Loop time of 17.3525 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.979 ns/day, 4.820 hours/ns, 57.629 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.164     | 17.164     | 17.164     |   0.0 | 98.91
Neigh   | 0.10813    | 0.10813    | 0.10813    |   0.0 |  0.62
Comm    | 0.013738   | 0.013738   | 0.013738   |   0.0 |  0.08
Output  | 2.3594e-05 | 2.3594e-05 | 2.3594e-05 |   0.0 |  0.00
Modify  | 0.061941   | 0.061941   | 0.061941   |   0.0 |  0.36
Other   |            | 0.004755   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3326 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119344 ave      119344 max      119344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119344
Ave neighs/atom = 59.672
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.410639185728, Press = 0.522906727408532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -3204.4407     -3204.4407     -3281.2078     -3281.2078      297.09675      297.09675      47309.489      47309.489      185.93732      185.93732    
     68000  -3208.7812     -3208.7812     -3282.9697     -3282.9697      287.11734      287.11734      47476.86       47476.86      -366.68944     -366.68944    
Loop time of 17.329 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.986 ns/day, 4.814 hours/ns, 57.707 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.141     | 17.141     | 17.141     |   0.0 | 98.91
Neigh   | 0.10802    | 0.10802    | 0.10802    |   0.0 |  0.62
Comm    | 0.013686   | 0.013686   | 0.013686   |   0.0 |  0.08
Output  | 2.3464e-05 | 2.3464e-05 | 2.3464e-05 |   0.0 |  0.00
Modify  | 0.061909   | 0.061909   | 0.061909   |   0.0 |  0.36
Other   |            | 0.004693   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3329 ave        3329 max        3329 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119154 ave      119154 max      119154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119154
Ave neighs/atom = 59.577
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.42222773658, Press = 0.581670146677829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -3208.7812     -3208.7812     -3282.9697     -3282.9697      287.11734      287.11734      47476.86       47476.86      -366.68944     -366.68944    
     69000  -3207.1942     -3207.1942     -3281.9006     -3281.9006      289.12141      289.12141      47410.633      47410.633     -350.92847     -350.92847    
Loop time of 17.3081 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.992 ns/day, 4.808 hours/ns, 57.777 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.12      | 17.12      | 17.12      |   0.0 | 98.91
Neigh   | 0.10759    | 0.10759    | 0.10759    |   0.0 |  0.62
Comm    | 0.01368    | 0.01368    | 0.01368    |   0.0 |  0.08
Output  | 3.2942e-05 | 3.2942e-05 | 3.2942e-05 |   0.0 |  0.00
Modify  | 0.061989   | 0.061989   | 0.061989   |   0.0 |  0.36
Other   |            | 0.004774   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3344 ave        3344 max        3344 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119134 ave      119134 max      119134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119134
Ave neighs/atom = 59.567
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.437821756003, Press = -0.209762795772129
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -3207.1942     -3207.1942     -3281.9006     -3281.9006      289.12141      289.12141      47410.633      47410.633     -350.92847     -350.92847    
     70000  -3206.9108     -3206.9108     -3285.4056     -3285.4056      303.78331      303.78331      47227.87       47227.87       235.84703      235.84703    
Loop time of 17.3312 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.985 ns/day, 4.814 hours/ns, 57.699 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.138     | 17.138     | 17.138     |   0.0 | 98.89
Neigh   | 0.11286    | 0.11286    | 0.11286    |   0.0 |  0.65
Comm    | 0.013689   | 0.013689   | 0.013689   |   0.0 |  0.08
Output  | 2.4627e-05 | 2.4627e-05 | 2.4627e-05 |   0.0 |  0.00
Modify  | 0.06186    | 0.06186    | 0.06186    |   0.0 |  0.36
Other   |            | 0.004706   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3372 ave        3372 max        3372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119176 ave      119176 max      119176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119176
Ave neighs/atom = 59.588
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.441882214329, Press = -0.582373836482189
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -3206.9108     -3206.9108     -3285.4056     -3285.4056      303.78331      303.78331      47227.87       47227.87       235.84703      235.84703    
     71000  -3203.8143     -3203.8143     -3281.051      -3281.051       298.91389      298.91389      47224.643      47224.643      322.70698      322.70698    
Loop time of 17.3392 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.983 ns/day, 4.816 hours/ns, 57.673 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.151     | 17.151     | 17.151     |   0.0 | 98.91
Neigh   | 0.10812    | 0.10812    | 0.10812    |   0.0 |  0.62
Comm    | 0.013716   | 0.013716   | 0.013716   |   0.0 |  0.08
Output  | 2.3885e-05 | 2.3885e-05 | 2.3885e-05 |   0.0 |  0.00
Modify  | 0.061914   | 0.061914   | 0.061914   |   0.0 |  0.36
Other   |            | 0.004671   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3314 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119588 ave      119588 max      119588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119588
Ave neighs/atom = 59.794
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.4164298687, Press = 0.182125291544554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -3203.8143     -3203.8143     -3281.051      -3281.051       298.91389      298.91389      47224.643      47224.643      322.70698      322.70698    
     72000  -3206.4154     -3206.4154     -3282.8188     -3282.8188      295.68897      295.68897      47342.62       47342.62      -117.16775     -117.16775    
Loop time of 17.298 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.995 ns/day, 4.805 hours/ns, 57.810 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.105     | 17.105     | 17.105     |   0.0 | 98.88
Neigh   | 0.11276    | 0.11276    | 0.11276    |   0.0 |  0.65
Comm    | 0.013778   | 0.013778   | 0.013778   |   0.0 |  0.08
Output  | 2.7011e-05 | 2.7011e-05 | 2.7011e-05 |   0.0 |  0.00
Modify  | 0.061872   | 0.061872   | 0.061872   |   0.0 |  0.36
Other   |            | 0.004698   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3349 ave        3349 max        3349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119268 ave      119268 max      119268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119268
Ave neighs/atom = 59.634
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.416662431011, Press = 0.133951478756466
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -3206.4154     -3206.4154     -3282.8188     -3282.8188      295.68897      295.68897      47342.62       47342.62      -117.16775     -117.16775    
     73000  -3207.0277     -3207.0277     -3282.1058     -3282.1058      290.56016      290.56016      47268.81       47268.81       230.97436      230.97436    
Loop time of 17.3594 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.977 ns/day, 4.822 hours/ns, 57.606 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.166     | 17.166     | 17.166     |   0.0 | 98.88
Neigh   | 0.11309    | 0.11309    | 0.11309    |   0.0 |  0.65
Comm    | 0.01383    | 0.01383    | 0.01383    |   0.0 |  0.08
Output  | 4.1107e-05 | 4.1107e-05 | 4.1107e-05 |   0.0 |  0.00
Modify  | 0.061978   | 0.061978   | 0.061978   |   0.0 |  0.36
Other   |            | 0.004699   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3345 ave        3345 max        3345 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119464 ave      119464 max      119464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119464
Ave neighs/atom = 59.732
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.380647477996, Press = 0.00626109641096869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -3207.0277     -3207.0277     -3282.1058     -3282.1058      290.56016      290.56016      47268.81       47268.81       230.97436      230.97436    
     74000  -3210.224      -3210.224      -3284.8517     -3284.8517      288.81698      288.81698      47060.183      47060.183      616.09552      616.09552    
Loop time of 17.3463 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.981 ns/day, 4.818 hours/ns, 57.649 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.158     | 17.158     | 17.158     |   0.0 | 98.91
Neigh   | 0.1079     | 0.1079     | 0.1079     |   0.0 |  0.62
Comm    | 0.013692   | 0.013692   | 0.013692   |   0.0 |  0.08
Output  | 2.5678e-05 | 2.5678e-05 | 2.5678e-05 |   0.0 |  0.00
Modify  | 0.061906   | 0.061906   | 0.061906   |   0.0 |  0.36
Other   |            | 0.004689   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3335 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119790 ave      119790 max      119790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119790
Ave neighs/atom = 59.895
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.386634250088, Press = 0.106369706640459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -3210.224      -3210.224      -3284.8517     -3284.8517      288.81698      288.81698      47060.183      47060.183      616.09552      616.09552    
     75000  -3209.1324     -3209.1324     -3282.9018     -3282.9018      285.49492      285.49492      47224.127      47224.127      44.202725      44.202725    
Loop time of 17.3685 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.975 ns/day, 4.825 hours/ns, 57.575 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.181     | 17.181     | 17.181     |   0.0 | 98.92
Neigh   | 0.10749    | 0.10749    | 0.10749    |   0.0 |  0.62
Comm    | 0.013762   | 0.013762   | 0.013762   |   0.0 |  0.08
Output  | 2.3304e-05 | 2.3304e-05 | 2.3304e-05 |   0.0 |  0.00
Modify  | 0.061929   | 0.061929   | 0.061929   |   0.0 |  0.36
Other   |            | 0.00469    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3332 ave        3332 max        3332 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120034 ave      120034 max      120034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120034
Ave neighs/atom = 60.017
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.354875252127, Press = 0.919660926412537
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -3209.1324     -3209.1324     -3282.9018     -3282.9018      285.49492      285.49492      47224.127      47224.127      44.202725      44.202725    
     76000  -3208.5058     -3208.5058     -3281.0855     -3281.0855      280.89067      280.89067      47457.74       47457.74      -288.51218     -288.51218    
Loop time of 17.3665 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.975 ns/day, 4.824 hours/ns, 57.582 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.173     | 17.173     | 17.173     |   0.0 | 98.88
Neigh   | 0.11342    | 0.11342    | 0.11342    |   0.0 |  0.65
Comm    | 0.013769   | 0.013769   | 0.013769   |   0.0 |  0.08
Output  | 3.5337e-05 | 3.5337e-05 | 3.5337e-05 |   0.0 |  0.00
Modify  | 0.06195    | 0.06195    | 0.06195    |   0.0 |  0.36
Other   |            | 0.004692   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3362 ave        3362 max        3362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119014 ave      119014 max      119014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0