# 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.532111041247845*${_u_distance}
variable latticeconst_converted equal 3.532111041247845*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.53211104124785
Lattice spacing in x,y,z = 3.532111 3.532111 3.532111
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.32111 35.32111 35.32111)
  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.32111 35.32111 35.32111)
  create_atoms CPU = 0.003 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_KimJungLee_2012_LiMg__MO_427397414195_002
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 44065.9406253475    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 44065.9406253475/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 44065.9406253475/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 44065.9406253475/(1*1*${_u_distance})
variable      V0_metal equal 44065.9406253475/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 44065.9406253475*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  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  -3226.1992     -3226.1992     -3296.7787     -3296.7787      273.15         273.15         44065.941      44065.941      1710.7831      1710.7831    
      1000  -3144.6448     -3144.6448     -3218.6805     -3218.6805      286.52578      286.52578      44647.75       44647.75      -153.52478     -153.52478    
Loop time of 188.308 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.459 ns/day, 52.308 hours/ns, 5.310 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 187.4      | 187.4      | 187.4      |   0.0 | 99.52
Neigh   | 0.38699    | 0.38699    | 0.38699    |   0.0 |  0.21
Comm    | 0.093591   | 0.093591   | 0.093591   |   0.0 |  0.05
Output  | 0.00021604 | 0.00021604 | 0.00021604 |   0.0 |  0.00
Modify  | 0.37325    | 0.37325    | 0.37325    |   0.0 |  0.20
Other   |            | 0.05698    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3309 ave        3309 max        3309 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120828 ave      120828 max      120828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120828
Ave neighs/atom = 60.414
Neighbor list builds = 17
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -3144.6448     -3144.6448     -3218.6805     -3218.6805      286.52578      286.52578      44647.75       44647.75      -153.52478     -153.52478    
      2000  -3152.0256     -3152.0256     -3221.0522     -3221.0522      267.14014      267.14014      44347.607      44347.607      373.53814      373.53814    
Loop time of 204.15 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.708 hours/ns, 4.898 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.08     | 203.08     | 203.08     |   0.0 | 99.48
Neigh   | 0.49654    | 0.49654    | 0.49654    |   0.0 |  0.24
Comm    | 0.1019     | 0.1019     | 0.1019     |   0.0 |  0.05
Output  | 0.00025892 | 0.00025892 | 0.00025892 |   0.0 |  0.00
Modify  | 0.41267    | 0.41267    | 0.41267    |   0.0 |  0.20
Other   |            | 0.05982    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3278 ave        3278 max        3278 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121062 ave      121062 max      121062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121062
Ave neighs/atom = 60.531
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -3152.0256     -3152.0256     -3221.0522     -3221.0522      267.14014      267.14014      44347.607      44347.607      373.53814      373.53814    
      3000  -3146.2425     -3146.2425     -3216.2449     -3216.2449      270.91638      270.91638      44684.556      44684.556     -275.54492     -275.54492    
Loop time of 203.829 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.619 hours/ns, 4.906 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.75     | 202.75     | 202.75     |   0.0 | 99.47
Neigh   | 0.49306    | 0.49306    | 0.49306    |   0.0 |  0.24
Comm    | 0.1024     | 0.1024     | 0.1024     |   0.0 |  0.05
Output  | 0.00025708 | 0.00025708 | 0.00025708 |   0.0 |  0.00
Modify  | 0.41878    | 0.41878    | 0.41878    |   0.0 |  0.21
Other   |            | 0.06054    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3398 ave        3398 max        3398 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120972 ave      120972 max      120972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120972
Ave neighs/atom = 60.486
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   
      3000  -3146.2425     -3146.2425     -3216.2449     -3216.2449      270.91638      270.91638      44684.556      44684.556     -275.54492     -275.54492    
      4000  -3151.7548     -3151.7548     -3220.9569     -3220.9569      267.81921      267.81921      44524.169      44524.169     -85.557834     -85.557834    
Loop time of 203.871 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.631 hours/ns, 4.905 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.78     | 202.78     | 202.78     |   0.0 | 99.46
Neigh   | 0.51545    | 0.51545    | 0.51545    |   0.0 |  0.25
Comm    | 0.10255    | 0.10255    | 0.10255    |   0.0 |  0.05
Output  | 0.00020653 | 0.00020653 | 0.00020653 |   0.0 |  0.00
Modify  | 0.41612    | 0.41612    | 0.41612    |   0.0 |  0.20
Other   |            | 0.05981    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3275 ave        3275 max        3275 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120834 ave      120834 max      120834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120834
Ave neighs/atom = 60.417
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  -3151.7548     -3151.7548     -3220.9569     -3220.9569      267.81921      267.81921      44524.169      44524.169     -85.557834     -85.557834    
      5000  -3146.1813     -3146.1813     -3218.7906     -3218.7906      281.00535      281.00535      44516.862      44516.862      120.85658      120.85658    
Loop time of 203.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.621 hours/ns, 4.906 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.76     | 202.76     | 202.76     |   0.0 | 99.47
Neigh   | 0.49505    | 0.49505    | 0.49505    |   0.0 |  0.24
Comm    | 0.10245    | 0.10245    | 0.10245    |   0.0 |  0.05
Output  | 0.00016804 | 0.00016804 | 0.00016804 |   0.0 |  0.00
Modify  | 0.41868    | 0.41868    | 0.41868    |   0.0 |  0.21
Other   |            | 0.06033    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3318 ave        3318 max        3318 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121322 ave      121322 max      121322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121322
Ave neighs/atom = 60.661
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 275.411251815562, Press = 121.350237745591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
      5000  -3146.1813     -3146.1813     -3218.7906     -3218.7906      281.00535      281.00535      44516.862      44516.862      120.85658      120.85658    
      6000  -3151.6829     -3151.6829     -3219.4355     -3219.4355      262.20975      262.20975      44498.318      44498.318      84.33692       84.33692     
Loop time of 203.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.619 hours/ns, 4.906 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.73     | 202.73     | 202.73     |   0.0 | 99.46
Neigh   | 0.49491    | 0.49491    | 0.49491    |   0.0 |  0.24
Comm    | 0.10251    | 0.10251    | 0.10251    |   0.0 |  0.05
Output  | 0.00016561 | 0.00016561 | 0.00016561 |   0.0 |  0.00
Modify  | 0.43884    | 0.43884    | 0.43884    |   0.0 |  0.22
Other   |            | 0.06005    |            |       |  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:       121136 ave      121136 max      121136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121136
Ave neighs/atom = 60.568
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.487293532821, Press = 41.7613274245056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3151.6829     -3151.6829     -3219.4355     -3219.4355      262.20975      262.20975      44498.318      44498.318      84.33692       84.33692     
      7000  -3145.9429     -3145.9429     -3218.1924     -3218.1924      279.61314      279.61314      44769.966      44769.966     -511.73244     -511.73244    
Loop time of 203.453 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.515 hours/ns, 4.915 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.32     | 202.32     | 202.32     |   0.0 | 99.45
Neigh   | 0.52335    | 0.52335    | 0.52335    |   0.0 |  0.26
Comm    | 0.10416    | 0.10416    | 0.10416    |   0.0 |  0.05
Output  | 0.00016647 | 0.00016647 | 0.00016647 |   0.0 |  0.00
Modify  | 0.43977    | 0.43977    | 0.43977    |   0.0 |  0.22
Other   |            | 0.06058    |            |       |  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:       120730 ave      120730 max      120730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120730
Ave neighs/atom = 60.365
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 = 272.849970035202, Press = -5.65510607447772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
      7000  -3145.9429     -3145.9429     -3218.1924     -3218.1924      279.61314      279.61314      44769.966      44769.966     -511.73244     -511.73244    
      8000  -3153.4025     -3153.4025     -3221.2549     -3221.2549      262.59581      262.59581      44335.27       44335.27       313.66147      313.66147    
Loop time of 204.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.704 hours/ns, 4.899 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.02     | 203.02     | 203.02     |   0.0 | 99.45
Neigh   | 0.51994    | 0.51994    | 0.51994    |   0.0 |  0.25
Comm    | 0.10256    | 0.10256    | 0.10256    |   0.0 |  0.05
Output  | 0.00016715 | 0.00016715 | 0.00016715 |   0.0 |  0.00
Modify  | 0.43613    | 0.43613    | 0.43613    |   0.0 |  0.21
Other   |            | 0.06008    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3323 ave        3323 max        3323 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121146 ave      121146 max      121146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121146
Ave neighs/atom = 60.573
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 = 272.466758054443, Press = -7.37194000499841
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
      8000  -3153.4025     -3153.4025     -3221.2549     -3221.2549      262.59581      262.59581      44335.27       44335.27       313.66147      313.66147    
      9000  -3147.6815     -3147.6815     -3218.8499     -3218.8499      275.42884      275.42884      44506.252      44506.252      127.6901       127.6901     
Loop time of 205.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 56.965 hours/ns, 4.876 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.95     | 203.95     | 203.95     |   0.0 | 99.45
Neigh   | 0.5247     | 0.5247     | 0.5247     |   0.0 |  0.26
Comm    | 0.10335    | 0.10335    | 0.10335    |   0.0 |  0.05
Output  | 0.00016885 | 0.00016885 | 0.00016885 |   0.0 |  0.00
Modify  | 0.43731    | 0.43731    | 0.43731    |   0.0 |  0.21
Other   |            | 0.05997    |            |       |  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:       121030 ave      121030 max      121030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121030
Ave neighs/atom = 60.515
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 = 272.541484457344, Press = 9.07388678513428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
      9000  -3147.6815     -3147.6815     -3218.8499     -3218.8499      275.42884      275.42884      44506.252      44506.252      127.6901       127.6901     
     10000  -3148.109      -3148.109      -3219.137      -3219.137       274.88554      274.88554      44592.865      44592.865     -172.16925     -172.16925    
Loop time of 205.19 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 56.997 hours/ns, 4.874 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.08     | 204.08     | 204.08     |   0.0 | 99.46
Neigh   | 0.5011     | 0.5011     | 0.5011     |   0.0 |  0.24
Comm    | 0.10317    | 0.10317    | 0.10317    |   0.0 |  0.05
Output  | 0.00016804 | 0.00016804 | 0.00016804 |   0.0 |  0.00
Modify  | 0.4422     | 0.4422     | 0.4422     |   0.0 |  0.22
Other   |            | 0.06026    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3309 ave        3309 max        3309 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120888 ave      120888 max      120888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120888
Ave neighs/atom = 60.444
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.535144188969, Press = 3.12004871422983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.109      -3148.109      -3219.137      -3219.137       274.88554      274.88554      44592.865      44592.865     -172.16925     -172.16925    
     11000  -3150.0001     -3150.0001     -3220.814      -3220.814       274.05724      274.05724      44429.48       44429.48       227.11704      227.11704    
Loop time of 205.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 57.058 hours/ns, 4.868 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.28     | 204.28     | 204.28     |   0.0 | 99.45
Neigh   | 0.52419    | 0.52419    | 0.52419    |   0.0 |  0.26
Comm    | 0.10494    | 0.10494    | 0.10494    |   0.0 |  0.05
Output  | 0.00021393 | 0.00021393 | 0.00021393 |   0.0 |  0.00
Modify  | 0.44316    | 0.44316    | 0.44316    |   0.0 |  0.22
Other   |            | 0.06016    |            |       |  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:       121018 ave      121018 max      121018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121018
Ave neighs/atom = 60.509
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 = 272.723784434552, Press = -1.81925144293268
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     11000  -3150.0001     -3150.0001     -3220.814      -3220.814       274.05724      274.05724      44429.48       44429.48       227.11704      227.11704    
     12000  -3146.7869     -3146.7869     -3219.8107     -3219.8107      282.60949      282.60949      44601.864      44601.864     -210.2867      -210.2867     
Loop time of 190.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.452 ns/day, 53.052 hours/ns, 5.236 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 189.93     | 189.93     | 189.93     |   0.0 | 99.45
Neigh   | 0.49629    | 0.49629    | 0.49629    |   0.0 |  0.26
Comm    | 0.097383   | 0.097383   | 0.097383   |   0.0 |  0.05
Output  | 0.00020029 | 0.00020029 | 0.00020029 |   0.0 |  0.00
Modify  | 0.40227    | 0.40227    | 0.40227    |   0.0 |  0.21
Other   |            | 0.05815    |            |       |  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:       120954 ave      120954 max      120954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120954
Ave neighs/atom = 60.477
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 = 272.907408276538, Press = 3.61366057767182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3146.7869     -3146.7869     -3219.8107     -3219.8107      282.60949      282.60949      44601.864      44601.864     -210.2867      -210.2867     
     13000  -3148.4166     -3148.4166     -3219.0782     -3219.0782      273.46784      273.46784      44616.564      44616.564     -155.37888     -155.37888    
Loop time of 181.536 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.476 ns/day, 50.427 hours/ns, 5.509 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 180.53     | 180.53     | 180.53     |   0.0 | 99.44
Neigh   | 0.48383    | 0.48383    | 0.48383    |   0.0 |  0.27
Comm    | 0.09294    | 0.09294    | 0.09294    |   0.0 |  0.05
Output  | 0.00020256 | 0.00020256 | 0.00020256 |   0.0 |  0.00
Modify  | 0.37678    | 0.37678    | 0.37678    |   0.0 |  0.21
Other   |            | 0.05574    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3343 ave        3343 max        3343 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121072 ave      121072 max      121072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121072
Ave neighs/atom = 60.536
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 = 272.980616156307, Press = -2.12075388796691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.4166     -3148.4166     -3219.0782     -3219.0782      273.46784      273.46784      44616.564      44616.564     -155.37888     -155.37888    
     14000  -3147.4701     -3147.4701     -3218.8384     -3218.8384      276.20248      276.20248      44305.37       44305.37       614.99277      614.99277    
Loop time of 174.649 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.514 hours/ns, 5.726 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.67     | 173.67     | 173.67     |   0.0 | 99.44
Neigh   | 0.47706    | 0.47706    | 0.47706    |   0.0 |  0.27
Comm    | 0.089953   | 0.089953   | 0.089953   |   0.0 |  0.05
Output  | 0.00043875 | 0.00043875 | 0.00043875 |   0.0 |  0.00
Modify  | 0.35563    | 0.35563    | 0.35563    |   0.0 |  0.20
Other   |            | 0.05463    |            |       |  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:       121282 ave      121282 max      121282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121282
Ave neighs/atom = 60.641
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 = 272.953593917224, Press = 2.36401746902975
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3147.4701     -3147.4701     -3218.8384     -3218.8384      276.20248      276.20248      44305.37       44305.37       614.99277      614.99277    
     15000  -3148.5527     -3148.5527     -3219.0763     -3219.0763      272.93384      272.93384      44704.501      44704.501     -378.76594     -378.76594    
Loop time of 174.076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.354 hours/ns, 5.745 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.1      | 173.1      | 173.1      |   0.0 | 99.44
Neigh   | 0.47518    | 0.47518    | 0.47518    |   0.0 |  0.27
Comm    | 0.089832   | 0.089832   | 0.089832   |   0.0 |  0.05
Output  | 0.00016877 | 0.00016877 | 0.00016877 |   0.0 |  0.00
Modify  | 0.35519    | 0.35519    | 0.35519    |   0.0 |  0.20
Other   |            | 0.05513    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3318 ave        3318 max        3318 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121092 ave      121092 max      121092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121092
Ave neighs/atom = 60.546
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 = 273.054058378031, Press = 5.64363312001825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.5527     -3148.5527     -3219.0763     -3219.0763      272.93384      272.93384      44704.501      44704.501     -378.76594     -378.76594    
     16000  -3149.0676     -3149.0676     -3219.7135     -3219.7135      273.40699      273.40699      44645.332      44645.332     -350.05549     -350.05549    
Loop time of 204.549 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.819 hours/ns, 4.889 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.42     | 203.42     | 203.42     |   0.0 | 99.45
Neigh   | 0.5223     | 0.5223     | 0.5223     |   0.0 |  0.26
Comm    | 0.10295    | 0.10295    | 0.10295    |   0.0 |  0.05
Output  | 0.00021841 | 0.00021841 | 0.00021841 |   0.0 |  0.00
Modify  | 0.44168    | 0.44168    | 0.44168    |   0.0 |  0.22
Other   |            | 0.05959    |            |       |  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:       120954 ave      120954 max      120954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120954
Ave neighs/atom = 60.477
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 = 272.811755955434, Press = -1.09318814609429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3149.0676     -3149.0676     -3219.7135     -3219.7135      273.40699      273.40699      44645.332      44645.332     -350.05549     -350.05549    
     17000  -3153.0307     -3153.0307     -3222.6985     -3222.6985      269.62187      269.62187      44271.709      44271.709      520.46398      520.46398    
Loop time of 204.334 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.760 hours/ns, 4.894 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.2      | 203.2      | 203.2      |   0.0 | 99.44
Neigh   | 0.52595    | 0.52595    | 0.52595    |   0.0 |  0.26
Comm    | 0.1039     | 0.1039     | 0.1039     |   0.0 |  0.05
Output  | 0.00017073 | 0.00017073 | 0.00017073 |   0.0 |  0.00
Modify  | 0.44364    | 0.44364    | 0.44364    |   0.0 |  0.22
Other   |            | 0.06092    |            |       |  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:       121144 ave      121144 max      121144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121144
Ave neighs/atom = 60.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 = 272.798076815136, Press = 0.188392760237874
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3153.0307     -3153.0307     -3222.6985     -3222.6985      269.62187      269.62187      44271.709      44271.709      520.46398      520.46398    
     18000  -3147.5316     -3147.5316     -3218.4612     -3218.4612      274.50481      274.50481      44526.118      44526.118      86.127697      86.127697    
Loop time of 202.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.176 hours/ns, 4.945 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.11     | 201.11     | 201.11     |   0.0 | 99.45
Neigh   | 0.51844    | 0.51844    | 0.51844    |   0.0 |  0.26
Comm    | 0.10335    | 0.10335    | 0.10335    |   0.0 |  0.05
Output  | 0.00016856 | 0.00016856 | 0.00016856 |   0.0 |  0.00
Modify  | 0.43833    | 0.43833    | 0.43833    |   0.0 |  0.22
Other   |            | 0.06076    |            |       |  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:       121076 ave      121076 max      121076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121076
Ave neighs/atom = 60.538
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 = 272.637000238852, Press = 3.63551774960325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3147.5316     -3147.5316     -3218.4612     -3218.4612      274.50481      274.50481      44526.118      44526.118      86.127697      86.127697    
     19000  -3149.1588     -3149.1588     -3220.0448     -3220.0448      274.33601      274.33601      44610.157      44610.157     -268.30944     -268.30944    
Loop time of 191.49 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.451 ns/day, 53.192 hours/ns, 5.222 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.45     | 190.45     | 190.45     |   0.0 | 99.46
Neigh   | 0.47874    | 0.47874    | 0.47874    |   0.0 |  0.25
Comm    | 0.097581   | 0.097581   | 0.097581   |   0.0 |  0.05
Output  | 0.00021638 | 0.00021638 | 0.00021638 |   0.0 |  0.00
Modify  | 0.40308    | 0.40308    | 0.40308    |   0.0 |  0.21
Other   |            | 0.05853    |            |       |  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:       120914 ave      120914 max      120914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120914
Ave neighs/atom = 60.457
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.616951866835, Press = -0.0308074298855909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3149.1588     -3149.1588     -3220.0448     -3220.0448      274.33601      274.33601      44610.157      44610.157     -268.30944     -268.30944    
     20000  -3147.8446     -3147.8446     -3218.719      -3218.719       274.29137      274.29137      44565.749      44565.749     -86.308772     -86.308772    
Loop time of 204.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.701 hours/ns, 4.899 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.02     | 203.02     | 203.02     |   0.0 | 99.46
Neigh   | 0.49947    | 0.49947    | 0.49947    |   0.0 |  0.24
Comm    | 0.10248    | 0.10248    | 0.10248    |   0.0 |  0.05
Output  | 0.00021324 | 0.00021324 | 0.00021324 |   0.0 |  0.00
Modify  | 0.44096    | 0.44096    | 0.44096    |   0.0 |  0.22
Other   |            | 0.06051    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3311 ave        3311 max        3311 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121074 ave      121074 max      121074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121074
Ave neighs/atom = 60.537
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.540699205416, Press = 1.27987264337504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     20000  -3147.8446     -3147.8446     -3218.719      -3218.719       274.29137      274.29137      44565.749      44565.749     -86.308772     -86.308772    
     21000  -3149.6907     -3149.6907     -3217.0685     -3217.0685      260.7592       260.7592       44475.488      44475.488      229.41771      229.41771    
Loop time of 204.082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.689 hours/ns, 4.900 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.98     | 202.98     | 202.98     |   0.0 | 99.46
Neigh   | 0.49728    | 0.49728    | 0.49728    |   0.0 |  0.24
Comm    | 0.10203    | 0.10203    | 0.10203    |   0.0 |  0.05
Output  | 0.00016727 | 0.00016727 | 0.00016727 |   0.0 |  0.00
Modify  | 0.44226    | 0.44226    | 0.44226    |   0.0 |  0.22
Other   |            | 0.06003    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3346 ave        3346 max        3346 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121226 ave      121226 max      121226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121226
Ave neighs/atom = 60.613
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.490972481702, Press = 1.13116509825894
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     21000  -3149.6907     -3149.6907     -3217.0685     -3217.0685      260.7592       260.7592       44475.488      44475.488      229.41771      229.41771    
     22000  -3144.7317     -3144.7317     -3217.2321     -3217.2321      280.5842       280.5842       44639.868      44639.868     -165.55339     -165.55339    
Loop time of 203.693 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.581 hours/ns, 4.909 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.59     | 202.59     | 202.59     |   0.0 | 99.46
Neigh   | 0.49842    | 0.49842    | 0.49842    |   0.0 |  0.24
Comm    | 0.10319    | 0.10319    | 0.10319    |   0.0 |  0.05
Output  | 0.00021424 | 0.00021424 | 0.00021424 |   0.0 |  0.00
Modify  | 0.43957    | 0.43957    | 0.43957    |   0.0 |  0.22
Other   |            | 0.06062    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3268 ave        3268 max        3268 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121004 ave      121004 max      121004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121004
Ave neighs/atom = 60.502
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.639311767461, Press = 0.625396721764747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     22000  -3144.7317     -3144.7317     -3217.2321     -3217.2321      280.5842       280.5842       44639.868      44639.868     -165.55339     -165.55339    
     23000  -3150.1936     -3150.1936     -3219.3789     -3219.3789      267.7543       267.7543       44418.832      44418.832      258.66753      258.66753    
Loop time of 203.877 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.633 hours/ns, 4.905 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.78     | 202.78     | 202.78     |   0.0 | 99.46
Neigh   | 0.49669    | 0.49669    | 0.49669    |   0.0 |  0.24
Comm    | 0.10177    | 0.10177    | 0.10177    |   0.0 |  0.05
Output  | 0.00020676 | 0.00020676 | 0.00020676 |   0.0 |  0.00
Modify  | 0.44025    | 0.44025    | 0.44025    |   0.0 |  0.22
Other   |            | 0.06055    |            |       |  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:       121130 ave      121130 max      121130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121130
Ave neighs/atom = 60.565
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.683642148734, Press = -0.231271264022049
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3150.1936     -3150.1936     -3219.3789     -3219.3789      267.7543       267.7543       44418.832      44418.832      258.66753      258.66753    
     24000  -3147.8225     -3147.8225     -3217.2017     -3217.2017      268.50462      268.50462      44324.198      44324.198      611.54761      611.54761    
Loop time of 201.165 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.429 ns/day, 55.879 hours/ns, 4.971 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.05     | 200.05     | 200.05     |   0.0 | 99.45
Neigh   | 0.51674    | 0.51674    | 0.51674    |   0.0 |  0.26
Comm    | 0.10212    | 0.10212    | 0.10212    |   0.0 |  0.05
Output  | 0.00016939 | 0.00016939 | 0.00016939 |   0.0 |  0.00
Modify  | 0.43222    | 0.43222    | 0.43222    |   0.0 |  0.21
Other   |            | 0.06027    |            |       |  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:       121288 ave      121288 max      121288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121288
Ave neighs/atom = 60.644
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 = 272.689234828439, Press = 1.49570502524061
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3147.8225     -3147.8225     -3217.2017     -3217.2017      268.50462      268.50462      44324.198      44324.198      611.54761      611.54761    
     25000  -3146.3139     -3146.3139     -3216.9958     -3216.9958      273.54615      273.54615      44612.562      44612.562     -93.617146     -93.617146    
Loop time of 175.463 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.740 hours/ns, 5.699 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.5      | 174.5      | 174.5      |   0.0 | 99.45
Neigh   | 0.45917    | 0.45917    | 0.45917    |   0.0 |  0.26
Comm    | 0.090664   | 0.090664   | 0.090664   |   0.0 |  0.05
Output  | 0.00020118 | 0.00020118 | 0.00020118 |   0.0 |  0.00
Modify  | 0.35626    | 0.35626    | 0.35626    |   0.0 |  0.20
Other   |            | 0.0552     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3270 ave        3270 max        3270 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121040 ave      121040 max      121040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121040
Ave neighs/atom = 60.52
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.716373623643, Press = 1.63949155140614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     25000  -3146.3139     -3146.3139     -3216.9958     -3216.9958      273.54615      273.54615      44612.562      44612.562     -93.617146     -93.617146    
     26000  -3148.4448     -3148.4448     -3218.6579     -3218.6579      271.73195      271.73195      44628.687      44628.687     -236.9315      -236.9315     
Loop time of 175.069 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.630 hours/ns, 5.712 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.11     | 174.11     | 174.11     |   0.0 | 99.45
Neigh   | 0.45754    | 0.45754    | 0.45754    |   0.0 |  0.26
Comm    | 0.090787   | 0.090787   | 0.090787   |   0.0 |  0.05
Output  | 0.00016724 | 0.00016724 | 0.00016724 |   0.0 |  0.00
Modify  | 0.35841    | 0.35841    | 0.35841    |   0.0 |  0.20
Other   |            | 0.05491    |            |       |  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:       121114 ave      121114 max      121114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121114
Ave neighs/atom = 60.557
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.811276432549, Press = -0.0620088752487079
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.4448     -3148.4448     -3218.6579     -3218.6579      271.73195      271.73195      44628.687      44628.687     -236.9315      -236.9315     
     27000  -3145.4895     -3145.4895     -3217.1195     -3217.1195      277.21558      277.21558      44589.216      44589.216     -40.581329     -40.581329    
Loop time of 200.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.432 ns/day, 55.580 hours/ns, 4.998 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.98     | 198.98     | 198.98     |   0.0 | 99.45
Neigh   | 0.51503    | 0.51503    | 0.51503    |   0.0 |  0.26
Comm    | 0.10214    | 0.10214    | 0.10214    |   0.0 |  0.05
Output  | 0.00017041 | 0.00017041 | 0.00017041 |   0.0 |  0.00
Modify  | 0.43093    | 0.43093    | 0.43093    |   0.0 |  0.22
Other   |            | 0.06025    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3286 ave        3286 max        3286 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121072 ave      121072 max      121072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121072
Ave neighs/atom = 60.536
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 = 272.820089731953, Press = 0.00335638376944033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     27000  -3145.4895     -3145.4895     -3217.1195     -3217.1195      277.21558      277.21558      44589.216      44589.216     -40.581329     -40.581329    
     28000  -3148.9995     -3148.9995     -3217.7605     -3217.7605      266.11219      266.11219      44343.804      44343.804      486.56698      486.56698    
Loop time of 204.521 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.811 hours/ns, 4.889 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.42     | 203.42     | 203.42     |   0.0 | 99.46
Neigh   | 0.49892    | 0.49892    | 0.49892    |   0.0 |  0.24
Comm    | 0.10181    | 0.10181    | 0.10181    |   0.0 |  0.05
Output  | 0.00020813 | 0.00020813 | 0.00020813 |   0.0 |  0.00
Modify  | 0.44022    | 0.44022    | 0.44022    |   0.0 |  0.22
Other   |            | 0.05965    |            |       |  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:       121278 ave      121278 max      121278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121278
Ave neighs/atom = 60.639
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.937721862077, Press = 1.03322103447707
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     28000  -3148.9995     -3148.9995     -3217.7605     -3217.7605      266.11219      266.11219      44343.804      44343.804      486.56698      486.56698    
     29000  -3150.6278     -3150.6278     -3220.2741     -3220.2741      269.53841      269.53841      44734.735      44734.735     -605.68568     -605.68568    
Loop time of 204.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.798 hours/ns, 4.891 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.35     | 203.35     | 203.35     |   0.0 | 99.45
Neigh   | 0.51877    | 0.51877    | 0.51877    |   0.0 |  0.25
Comm    | 0.10354    | 0.10354    | 0.10354    |   0.0 |  0.05
Output  | 0.0002324  | 0.0002324  | 0.0002324  |   0.0 |  0.00
Modify  | 0.44448    | 0.44448    | 0.44448    |   0.0 |  0.22
Other   |            | 0.06062    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3206 ave        3206 max        3206 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120836 ave      120836 max      120836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120836
Ave neighs/atom = 60.418
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 = 272.972583062811, Press = 1.31613663449401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     29000  -3150.6278     -3150.6278     -3220.2741     -3220.2741      269.53841      269.53841      44734.735      44734.735     -605.68568     -605.68568    
     30000  -3148.1075     -3148.1075     -3218.654      -3218.654       273.02208      273.02208      44557.332      44557.332     -77.709496     -77.709496    
Loop time of 204.338 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.761 hours/ns, 4.894 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.22     | 203.22     | 203.22     |   0.0 | 99.45
Neigh   | 0.52148    | 0.52148    | 0.52148    |   0.0 |  0.26
Comm    | 0.10197    | 0.10197    | 0.10197    |   0.0 |  0.05
Output  | 0.00026669 | 0.00026669 | 0.00026669 |   0.0 |  0.00
Modify  | 0.43829    | 0.43829    | 0.43829    |   0.0 |  0.21
Other   |            | 0.05968    |            |       |  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:       120958 ave      120958 max      120958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120958
Ave neighs/atom = 60.479
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 = 272.938252144291, Press = -1.22372757136147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     30000  -3148.1075     -3148.1075     -3218.654      -3218.654       273.02208      273.02208      44557.332      44557.332     -77.709496     -77.709496    
     31000  -3149.131      -3149.131      -3218.6387     -3218.6387      269.00213      269.00213      44398.344      44398.344      334.22982      334.22982    
Loop time of 204.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.782 hours/ns, 4.892 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.32     | 203.32     | 203.32     |   0.0 | 99.46
Neigh   | 0.49399    | 0.49399    | 0.49399    |   0.0 |  0.24
Comm    | 0.10228    | 0.10228    | 0.10228    |   0.0 |  0.05
Output  | 0.0002034  | 0.0002034  | 0.0002034  |   0.0 |  0.00
Modify  | 0.44288    | 0.44288    | 0.44288    |   0.0 |  0.22
Other   |            | 0.06079    |            |       |  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:       121206 ave      121206 max      121206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121206
Ave neighs/atom = 60.603
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.899918851203, Press = 1.38314260768584
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3149.131      -3149.131      -3218.6387     -3218.6387      269.00213      269.00213      44398.344      44398.344      334.22982      334.22982    
     32000  -3149.4143     -3149.4143     -3220.5688     -3220.5688      275.37502      275.37502      44582.62       44582.62      -167.62073     -167.62073    
Loop time of 204.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.930 hours/ns, 4.879 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.82     | 203.82     | 203.82     |   0.0 | 99.45
Neigh   | 0.52472    | 0.52472    | 0.52472    |   0.0 |  0.26
Comm    | 0.10349    | 0.10349    | 0.10349    |   0.0 |  0.05
Output  | 0.00016795 | 0.00016795 | 0.00016795 |   0.0 |  0.00
Modify  | 0.444      | 0.444      | 0.444      |   0.0 |  0.22
Other   |            | 0.05992    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3309 ave        3309 max        3309 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120904 ave      120904 max      120904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120904
Ave neighs/atom = 60.452
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 = 272.882470037437, Press = 1.08356172985137
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3149.4143     -3149.4143     -3220.5688     -3220.5688      275.37502      275.37502      44582.62       44582.62      -167.62073     -167.62073    
     33000  -3148.8172     -3148.8172     -3219.0936     -3219.0936      271.97691      271.97691      44567.678      44567.678     -116.31854     -116.31854    
Loop time of 205.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.420 ns/day, 57.176 hours/ns, 4.858 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    | 204.7      | 204.7      | 204.7      |   0.0 | 99.45
Neigh   | 0.52224    | 0.52224    | 0.52224    |   0.0 |  0.25
Comm    | 0.10445    | 0.10445    | 0.10445    |   0.0 |  0.05
Output  | 0.00027797 | 0.00027797 | 0.00027797 |   0.0 |  0.00
Modify  | 0.44563    | 0.44563    | 0.44563    |   0.0 |  0.22
Other   |            | 0.06142    |            |       |  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:       121020 ave      121020 max      121020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121020
Ave neighs/atom = 60.51
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 = 272.798928253308, Press = -0.114205702155176
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.8172     -3148.8172     -3219.0936     -3219.0936      271.97691      271.97691      44567.678      44567.678     -116.31854     -116.31854    
     34000  -3150.9094     -3150.9094     -3223.3673     -3223.3673      280.41954      280.41954      44340.047      44340.047      414.79893      414.79893    
Loop time of 205.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 57.003 hours/ns, 4.873 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.1      | 204.1      | 204.1      |   0.0 | 99.46
Neigh   | 0.49898    | 0.49898    | 0.49898    |   0.0 |  0.24
Comm    | 0.10409    | 0.10409    | 0.10409    |   0.0 |  0.05
Output  | 0.00016994 | 0.00016994 | 0.00016994 |   0.0 |  0.00
Modify  | 0.44426    | 0.44426    | 0.44426    |   0.0 |  0.22
Other   |            | 0.06148    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3304 ave        3304 max        3304 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120922 ave      120922 max      120922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120922
Ave neighs/atom = 60.461
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824040826298, Press = 0.274979904802527
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     34000  -3150.9094     -3150.9094     -3223.3673     -3223.3673      280.41954      280.41954      44340.047      44340.047      414.79893      414.79893    
     35000  -3151.7249     -3151.7249     -3221.7814     -3221.7814      271.12573      271.12573      44367.792      44367.792      253.0236       253.0236     
Loop time of 205.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 57.059 hours/ns, 4.868 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.31     | 204.31     | 204.31     |   0.0 | 99.47
Neigh   | 0.49777    | 0.49777    | 0.49777    |   0.0 |  0.24
Comm    | 0.10297    | 0.10297    | 0.10297    |   0.0 |  0.05
Output  | 0.00017113 | 0.00017113 | 0.00017113 |   0.0 |  0.00
Modify  | 0.43605    | 0.43605    | 0.43605    |   0.0 |  0.21
Other   |            | 0.06038    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3299 ave        3299 max        3299 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121250 ave      121250 max      121250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121250
Ave neighs/atom = 60.625
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.729521462948, Press = 2.55328678892194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3151.7249     -3151.7249     -3221.7814     -3221.7814      271.12573      271.12573      44367.792      44367.792      253.0236       253.0236     
     36000  -3151.4441     -3151.4441     -3219.287      -3219.287       262.55897      262.55897      44756.75       44756.75      -636.80468     -636.80468    
Loop time of 203.624 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.562 hours/ns, 4.911 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.5      | 202.5      | 202.5      |   0.0 | 99.45
Neigh   | 0.52245    | 0.52245    | 0.52245    |   0.0 |  0.26
Comm    | 0.1033     | 0.1033     | 0.1033     |   0.0 |  0.05
Output  | 0.00021483 | 0.00021483 | 0.00021483 |   0.0 |  0.00
Modify  | 0.43887    | 0.43887    | 0.43887    |   0.0 |  0.22
Other   |            | 0.06029    |            |       |  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:       120848 ave      120848 max      120848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120848
Ave neighs/atom = 60.424
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 = 272.716382147652, Press = 0.542735403892406
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3151.4441     -3151.4441     -3219.287      -3219.287       262.55897      262.55897      44756.75       44756.75      -636.80468     -636.80468    
     37000  -3148.6039     -3148.6039     -3220.0417     -3220.0417      276.47151      276.47151      44457.016      44457.016      208.36744      208.36744    
Loop time of 203.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.580 hours/ns, 4.909 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.56     | 202.56     | 202.56     |   0.0 | 99.45
Neigh   | 0.52132    | 0.52132    | 0.52132    |   0.0 |  0.26
Comm    | 0.10242    | 0.10242    | 0.10242    |   0.0 |  0.05
Output  | 0.00016866 | 0.00016866 | 0.00016866 |   0.0 |  0.00
Modify  | 0.44096    | 0.44096    | 0.44096    |   0.0 |  0.22
Other   |            | 0.05963    |            |       |  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:       121044 ave      121044 max      121044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121044
Ave neighs/atom = 60.522
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 = 272.703592653292, Press = -0.0132016519882521
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.6039     -3148.6039     -3220.0417     -3220.0417      276.47151      276.47151      44457.016      44457.016      208.36744      208.36744    
     38000  -3148.3025     -3148.3025     -3220.7732     -3220.7732      280.46875      280.46875      44535.316      44535.316     -101.9484      -101.9484     
Loop time of 204.533 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.815 hours/ns, 4.889 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.39     | 203.39     | 203.39     |   0.0 | 99.44
Neigh   | 0.54534    | 0.54534    | 0.54534    |   0.0 |  0.27
Comm    | 0.1039     | 0.1039     | 0.1039     |   0.0 |  0.05
Output  | 0.00026029 | 0.00026029 | 0.00026029 |   0.0 |  0.00
Modify  | 0.43727    | 0.43727    | 0.43727    |   0.0 |  0.21
Other   |            | 0.06034    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3341 ave        3341 max        3341 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120924 ave      120924 max      120924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120924
Ave neighs/atom = 60.462
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 = 272.711119529405, Press = 1.21702060401155
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.3025     -3148.3025     -3220.7732     -3220.7732      280.46875      280.46875      44535.316      44535.316     -101.9484      -101.9484     
     39000  -3146.564      -3146.564      -3215.808      -3215.808       267.98152      267.98152      44666.138      44666.138     -288.09729     -288.09729    
Loop time of 201.864 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.073 hours/ns, 4.954 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.75     | 200.75     | 200.75     |   0.0 | 99.45
Neigh   | 0.51916    | 0.51916    | 0.51916    |   0.0 |  0.26
Comm    | 0.10192    | 0.10192    | 0.10192    |   0.0 |  0.05
Output  | 0.00020561 | 0.00020561 | 0.00020561 |   0.0 |  0.00
Modify  | 0.43426    | 0.43426    | 0.43426    |   0.0 |  0.22
Other   |            | 0.06021    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3312 ave        3312 max        3312 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120878 ave      120878 max      120878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120878
Ave neighs/atom = 60.439
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 = 272.77221526351, Press = -0.0059059770947471
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     39000  -3146.564      -3146.564      -3215.808      -3215.808       267.98152      267.98152      44666.138      44666.138     -288.09729     -288.09729    
     40000  -3147.6809     -3147.6809     -3219.1818     -3219.1818      276.71601      276.71601      44431.084      44431.084      272.53591      272.53591    
Loop time of 204.433 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.787 hours/ns, 4.892 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    | 203.33     | 203.33     | 203.33     |   0.0 | 99.46
Neigh   | 0.49955    | 0.49955    | 0.49955    |   0.0 |  0.24
Comm    | 0.10266    | 0.10266    | 0.10266    |   0.0 |  0.05
Output  | 0.00016816 | 0.00016816 | 0.00016816 |   0.0 |  0.00
Modify  | 0.44132    | 0.44132    | 0.44132    |   0.0 |  0.22
Other   |            | 0.05979    |            |       |  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:       121154 ave      121154 max      121154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121154
Ave neighs/atom = 60.577
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.786615255943, Press = 0.377895924849309
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3147.6809     -3147.6809     -3219.1818     -3219.1818      276.71601      276.71601      44431.084      44431.084      272.53591      272.53591    
     41000  -3151.4333     -3151.4333     -3221.045      -3221.045       269.40453      269.40453      44558.556      44558.556     -174.58878     -174.58878    
Loop time of 182.287 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.474 ns/day, 50.635 hours/ns, 5.486 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 181.27     | 181.27     | 181.27     |   0.0 | 99.44
Neigh   | 0.48869    | 0.48869    | 0.48869    |   0.0 |  0.27
Comm    | 0.094191   | 0.094191   | 0.094191   |   0.0 |  0.05
Output  | 0.00017116 | 0.00017116 | 0.00017116 |   0.0 |  0.00
Modify  | 0.38056    | 0.38056    | 0.38056    |   0.0 |  0.21
Other   |            | 0.05697    |            |       |  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:       121052 ave      121052 max      121052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121052
Ave neighs/atom = 60.526
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 = 272.773019580187, Press = 2.19073166451561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3151.4333     -3151.4333     -3221.045      -3221.045       269.40453      269.40453      44558.556      44558.556     -174.58878     -174.58878    
     42000  -3149.8276     -3149.8276     -3219.7479     -3219.7479      270.5991       270.5991       44681.304      44681.304     -469.45662     -469.45662    
Loop time of 176.146 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.930 hours/ns, 5.677 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.16     | 175.16     | 175.16     |   0.0 | 99.44
Neigh   | 0.47823    | 0.47823    | 0.47823    |   0.0 |  0.27
Comm    | 0.091339   | 0.091339   | 0.091339   |   0.0 |  0.05
Output  | 0.00017119 | 0.00017119 | 0.00017119 |   0.0 |  0.00
Modify  | 0.3609     | 0.3609     | 0.3609     |   0.0 |  0.20
Other   |            | 0.05501    |            |       |  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:       120702 ave      120702 max      120702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120702
Ave neighs/atom = 60.351
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 = 272.726674176425, Press = -0.113605426679486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     42000  -3149.8276     -3149.8276     -3219.7479     -3219.7479      270.5991       270.5991       44681.304      44681.304     -469.45662     -469.45662    
     43000  -3148.0074     -3148.0074     -3218.4942     -3218.4942      272.79127      272.79127      44376.346      44376.346      437.6214       437.6214     
Loop time of 197.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.968 hours/ns, 5.053 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.79     | 196.79     | 196.79     |   0.0 | 99.44
Neigh   | 0.51569    | 0.51569    | 0.51569    |   0.0 |  0.26
Comm    | 0.10079    | 0.10079    | 0.10079    |   0.0 |  0.05
Output  | 0.0001665  | 0.0001665  | 0.0001665  |   0.0 |  0.00
Modify  | 0.42324    | 0.42324    | 0.42324    |   0.0 |  0.21
Other   |            | 0.05935    |            |       |  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:       121144 ave      121144 max      121144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121144
Ave neighs/atom = 60.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 = 272.751136055835, Press = 0.159709456066151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.0074     -3148.0074     -3218.4942     -3218.4942      272.79127      272.79127      44376.346      44376.346      437.6214       437.6214     
     44000  -3148.6002     -3148.6002     -3219.406      -3219.406       274.02551      274.02551      44519.813      44519.813      42.745589      42.745589    
Loop time of 192.735 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.448 ns/day, 53.537 hours/ns, 5.188 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.7      | 191.7      | 191.7      |   0.0 | 99.46
Neigh   | 0.48052    | 0.48052    | 0.48052    |   0.0 |  0.25
Comm    | 0.097114   | 0.097114   | 0.097114   |   0.0 |  0.05
Output  | 0.00016796 | 0.00016796 | 0.00016796 |   0.0 |  0.00
Modify  | 0.40251    | 0.40251    | 0.40251    |   0.0 |  0.21
Other   |            | 0.05793    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3265 ave        3265 max        3265 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120932 ave      120932 max      120932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120932
Ave neighs/atom = 60.466
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.774804362684, Press = 1.6875152497729
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     44000  -3148.6002     -3148.6002     -3219.406      -3219.406       274.02551      274.02551      44519.813      44519.813      42.745589      42.745589    
     45000  -3147.3085     -3147.3085     -3219.2979     -3219.2979      278.60617      278.60617      44690.62       44690.62      -339.45239     -339.45239    
Loop time of 174.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.410 hours/ns, 5.738 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.3      | 173.3      | 173.3      |   0.0 | 99.44
Neigh   | 0.47613    | 0.47613    | 0.47613    |   0.0 |  0.27
Comm    | 0.090348   | 0.090348   | 0.090348   |   0.0 |  0.05
Output  | 0.000493   | 0.000493   | 0.000493   |   0.0 |  0.00
Modify  | 0.35669    | 0.35669    | 0.35669    |   0.0 |  0.20
Other   |            | 0.05541    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3336 ave        3336 max        3336 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120792 ave      120792 max      120792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120792
Ave neighs/atom = 60.396
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 = 272.836792947053, Press = 0.424609147018612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3147.3085     -3147.3085     -3219.2979     -3219.2979      278.60617      278.60617      44690.62       44690.62      -339.45239     -339.45239    
     46000  -3149.5271     -3149.5271     -3219.3198     -3219.3198      270.10515      270.10515      44463.719      44463.719      130.43114      130.43114    
Loop time of 174.317 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.421 hours/ns, 5.737 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.36     | 173.36     | 173.36     |   0.0 | 99.45
Neigh   | 0.45517    | 0.45517    | 0.45517    |   0.0 |  0.26
Comm    | 0.089566   | 0.089566   | 0.089566   |   0.0 |  0.05
Output  | 0.00016857 | 0.00016857 | 0.00016857 |   0.0 |  0.00
Modify  | 0.35715    | 0.35715    | 0.35715    |   0.0 |  0.20
Other   |            | 0.05594    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3268 ave        3268 max        3268 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121100 ave      121100 max      121100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121100
Ave neighs/atom = 60.55
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.859275575806, Press = 0.366505715382047
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     46000  -3149.5271     -3149.5271     -3219.3198     -3219.3198      270.10515      270.10515      44463.719      44463.719      130.43114      130.43114    
     47000  -3150.1909     -3150.1909     -3218.1869     -3218.1869      263.15135      263.15135      44471.448      44471.448      155.47608      155.47608    
Loop time of 174.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.506 hours/ns, 5.727 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.64     | 173.64     | 173.64     |   0.0 | 99.44
Neigh   | 0.47784    | 0.47784    | 0.47784    |   0.0 |  0.27
Comm    | 0.090178   | 0.090178   | 0.090178   |   0.0 |  0.05
Output  | 0.00021054 | 0.00021054 | 0.00021054 |   0.0 |  0.00
Modify  | 0.3557     | 0.3557     | 0.3557     |   0.0 |  0.20
Other   |            | 0.05571    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3382 ave        3382 max        3382 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121178 ave      121178 max      121178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121178
Ave neighs/atom = 60.589
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 = 272.899677727613, Press = 0.348209337036378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3150.1909     -3150.1909     -3218.1869     -3218.1869      263.15135      263.15135      44471.448      44471.448      155.47608      155.47608    
     48000  -3147.7483     -3147.7483     -3217.6436     -3217.6436      270.50191      270.50191      44551.976      44551.976     -39.981995     -39.981995    
Loop time of 191.93 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.450 ns/day, 53.314 hours/ns, 5.210 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.88     | 190.88     | 190.88     |   0.0 | 99.45
Neigh   | 0.48179    | 0.48179    | 0.48179    |   0.0 |  0.25
Comm    | 0.099271   | 0.099271   | 0.099271   |   0.0 |  0.05
Output  | 0.00016883 | 0.00016883 | 0.00016883 |   0.0 |  0.00
Modify  | 0.41068    | 0.41068    | 0.41068    |   0.0 |  0.21
Other   |            | 0.05832    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3303 ave        3303 max        3303 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121036 ave      121036 max      121036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121036
Ave neighs/atom = 60.518
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.896156176031, Press = 0.350198648186857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3147.7483     -3147.7483     -3217.6436     -3217.6436      270.50191      270.50191      44551.976      44551.976     -39.981995     -39.981995    
     49000  -3152.6461     -3152.6461     -3221.5853     -3221.5853      266.80184      266.80184      44483.142      44483.142     -0.25695551    -0.25695551   
Loop time of 203.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.638 hours/ns, 4.904 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.79     | 202.79     | 202.79     |   0.0 | 99.46
Neigh   | 0.49884    | 0.49884    | 0.49884    |   0.0 |  0.24
Comm    | 0.10243    | 0.10243    | 0.10243    |   0.0 |  0.05
Output  | 0.00023063 | 0.00023063 | 0.00023063 |   0.0 |  0.00
Modify  | 0.44284    | 0.44284    | 0.44284    |   0.0 |  0.22
Other   |            | 0.06025    |            |       |  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:       120928 ave      120928 max      120928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120928
Ave neighs/atom = 60.464
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.870013324848, Press = 0.486499402472969
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3152.6461     -3152.6461     -3221.5853     -3221.5853      266.80184      266.80184      44483.142      44483.142     -0.25695551    -0.25695551   
     50000  -3146.4745     -3146.4745     -3217.9325     -3217.9325      276.54998      276.54998      44661.985      44661.985     -266.5292      -266.5292     
Loop time of 204.404 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.779 hours/ns, 4.892 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    | 203.29     | 203.29     | 203.29     |   0.0 | 99.46
Neigh   | 0.50003    | 0.50003    | 0.50003    |   0.0 |  0.24
Comm    | 0.1035     | 0.1035     | 0.1035     |   0.0 |  0.05
Output  | 0.00017103 | 0.00017103 | 0.00017103 |   0.0 |  0.00
Modify  | 0.445      | 0.445      | 0.445      |   0.0 |  0.22
Other   |            | 0.0609     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3352 ave        3352 max        3352 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120914 ave      120914 max      120914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120914
Ave neighs/atom = 60.457
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.834686718488, Press = 0.570914636289629
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3146.4745     -3146.4745     -3217.9325     -3217.9325      276.54998      276.54998      44661.985      44661.985     -266.5292      -266.5292     
     51000  -3148.1926     -3148.1926     -3219.3458     -3219.3458      275.37008      275.37008      44487.886      44487.886      146.96668      146.96668    
Loop time of 204.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.794 hours/ns, 4.891 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.3      | 203.3      | 203.3      |   0.0 | 99.44
Neigh   | 0.54335    | 0.54335    | 0.54335    |   0.0 |  0.27
Comm    | 0.10365    | 0.10365    | 0.10365    |   0.0 |  0.05
Output  | 0.00021017 | 0.00021017 | 0.00021017 |   0.0 |  0.00
Modify  | 0.4468     | 0.4468     | 0.4468     |   0.0 |  0.22
Other   |            | 0.06089    |            |       |  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:       121070 ave      121070 max      121070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121070
Ave neighs/atom = 60.535
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 = 272.823573134146, Press = 0.285576945021293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.1926     -3148.1926     -3219.3458     -3219.3458      275.37008      275.37008      44487.886      44487.886      146.96668      146.96668    
     52000  -3147.2241     -3147.2241     -3219.4495     -3219.4495      279.51973      279.51973      44588.187      44588.187     -159.12696     -159.12696    
Loop time of 204.855 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.904 hours/ns, 4.882 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    | 203.73     | 203.73     | 203.73     |   0.0 | 99.45
Neigh   | 0.52       | 0.52       | 0.52       |   0.0 |  0.25
Comm    | 0.10359    | 0.10359    | 0.10359    |   0.0 |  0.05
Output  | 0.00017    | 0.00017    | 0.00017    |   0.0 |  0.00
Modify  | 0.43918    | 0.43918    | 0.43918    |   0.0 |  0.21
Other   |            | 0.06039    |            |       |  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:       120986 ave      120986 max      120986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120986
Ave neighs/atom = 60.493
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 = 272.820476390518, Press = 0.679713286061006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     52000  -3147.2241     -3147.2241     -3219.4495     -3219.4495      279.51973      279.51973      44588.187      44588.187     -159.12696     -159.12696    
     53000  -3149.2723     -3149.2723     -3219.3063     -3219.3063      271.03912      271.03912      44738.807      44738.807     -601.27518     -601.27518    
Loop time of 211.858 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.408 ns/day, 58.850 hours/ns, 4.720 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 210.69     | 210.69     | 210.69     |   0.0 | 99.45
Neigh   | 0.5331     | 0.5331     | 0.5331     |   0.0 |  0.25
Comm    | 0.10772    | 0.10772    | 0.10772    |   0.0 |  0.05
Output  | 0.00017021 | 0.00017021 | 0.00017021 |   0.0 |  0.00
Modify  | 0.46731    | 0.46731    | 0.46731    |   0.0 |  0.22
Other   |            | 0.06173    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3257 ave        3257 max        3257 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120746 ave      120746 max      120746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120746
Ave neighs/atom = 60.373
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 = 272.819525839292, Press = 0.44465534392573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     53000  -3149.2723     -3149.2723     -3219.3063     -3219.3063      271.03912      271.03912      44738.807      44738.807     -601.27518     -601.27518    
     54000  -3149.2995     -3149.2995     -3221.0595     -3221.0595      277.71858      277.71858      44392.779      44392.779      317.8326       317.8326     
Loop time of 195.749 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.375 hours/ns, 5.109 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.66     | 194.66     | 194.66     |   0.0 | 99.45
Neigh   | 0.51114    | 0.51114    | 0.51114    |   0.0 |  0.26
Comm    | 0.1008     | 0.1008     | 0.1008     |   0.0 |  0.05
Output  | 0.00016803 | 0.00016803 | 0.00016803 |   0.0 |  0.00
Modify  | 0.41532    | 0.41532    | 0.41532    |   0.0 |  0.21
Other   |            | 0.05859    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3376 ave        3376 max        3376 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121102 ave      121102 max      121102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121102
Ave neighs/atom = 60.551
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 = 272.829545591598, Press = -0.233912394061649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3149.2995     -3149.2995     -3221.0595     -3221.0595      277.71858      277.71858      44392.779      44392.779      317.8326       317.8326     
     55000  -3149.6525     -3149.6525     -3219.8998     -3219.8998      271.86427      271.86427      44414.918      44414.918      237.9902       237.9902     
Loop time of 192.374 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.449 ns/day, 53.437 hours/ns, 5.198 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.3      | 191.3      | 191.3      |   0.0 | 99.44
Neigh   | 0.50515    | 0.50515    | 0.50515    |   0.0 |  0.26
Comm    | 0.099738   | 0.099738   | 0.099738   |   0.0 |  0.05
Output  | 0.00016802 | 0.00016802 | 0.00016802 |   0.0 |  0.00
Modify  | 0.41152    | 0.41152    | 0.41152    |   0.0 |  0.21
Other   |            | 0.05794    |            |       |  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:       121118 ave      121118 max      121118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121118
Ave neighs/atom = 60.559
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 = 272.778766892313, Press = 0.73718384509751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3149.6525     -3149.6525     -3219.8998     -3219.8998      271.86427      271.86427      44414.918      44414.918      237.9902       237.9902     
     56000  -3145.2884     -3145.2884     -3218.1865     -3218.1865      282.12316      282.12316      44560.57       44560.57       31.564004      31.564004    
Loop time of 199.141 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.434 ns/day, 55.317 hours/ns, 5.022 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.04     | 198.04     | 198.04     |   0.0 | 99.45
Neigh   | 0.51677    | 0.51677    | 0.51677    |   0.0 |  0.26
Comm    | 0.10135    | 0.10135    | 0.10135    |   0.0 |  0.05
Output  | 0.00022212 | 0.00022212 | 0.00022212 |   0.0 |  0.00
Modify  | 0.42605    | 0.42605    | 0.42605    |   0.0 |  0.21
Other   |            | 0.05973    |            |       |  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:       121024 ave      121024 max      121024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121024
Ave neighs/atom = 60.512
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 = 272.784278887599, Press = 0.428647456469275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     56000  -3145.2884     -3145.2884     -3218.1865     -3218.1865      282.12316      282.12316      44560.57       44560.57       31.564004      31.564004    
     57000  -3150.365      -3150.365      -3220.6015     -3220.6015      271.82232      271.82232      44556.591      44556.591     -136.73867     -136.73867    
Loop time of 203.907 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.641 hours/ns, 4.904 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.78     | 202.78     | 202.78     |   0.0 | 99.45
Neigh   | 0.52228    | 0.52228    | 0.52228    |   0.0 |  0.26
Comm    | 0.10379    | 0.10379    | 0.10379    |   0.0 |  0.05
Output  | 0.00021634 | 0.00021634 | 0.00021634 |   0.0 |  0.00
Modify  | 0.44246    | 0.44246    | 0.44246    |   0.0 |  0.22
Other   |            | 0.06089    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3311 ave        3311 max        3311 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120908 ave      120908 max      120908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120908
Ave neighs/atom = 60.454
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 = 272.824897429981, Press = 0.400070152671285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     57000  -3150.365      -3150.365      -3220.6015     -3220.6015      271.82232      271.82232      44556.591      44556.591     -136.73867     -136.73867    
     58000  -3146.7007     -3146.7007     -3217.3173     -3217.3173      273.29383      273.29383      44587.892      44587.892     -79.195909     -79.195909    
Loop time of 203.995 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.665 hours/ns, 4.902 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.86     | 202.86     | 202.86     |   0.0 | 99.45
Neigh   | 0.52089    | 0.52089    | 0.52089    |   0.0 |  0.26
Comm    | 0.10371    | 0.10371    | 0.10371    |   0.0 |  0.05
Output  | 0.00016696 | 0.00016696 | 0.00016696 |   0.0 |  0.00
Modify  | 0.44544    | 0.44544    | 0.44544    |   0.0 |  0.22
Other   |            | 0.06057    |            |       |  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:       121066 ave      121066 max      121066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121066
Ave neighs/atom = 60.533
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 = 272.808440712766, Press = 0.00698246625405961
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3146.7007     -3146.7007     -3217.3173     -3217.3173      273.29383      273.29383      44587.892      44587.892     -79.195909     -79.195909    
     59000  -3148.3235     -3148.3235     -3219.358      -3219.358       274.91079      274.91079      44490.09       44490.09       121.84686      121.84686    
Loop time of 202.808 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.336 hours/ns, 4.931 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.68     | 201.68     | 201.68     |   0.0 | 99.44
Neigh   | 0.52093    | 0.52093    | 0.52093    |   0.0 |  0.26
Comm    | 0.10417    | 0.10417    | 0.10417    |   0.0 |  0.05
Output  | 0.00017149 | 0.00017149 | 0.00017149 |   0.0 |  0.00
Modify  | 0.44104    | 0.44104    | 0.44104    |   0.0 |  0.22
Other   |            | 0.06042    |            |       |  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:       121062 ave      121062 max      121062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121062
Ave neighs/atom = 60.531
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 = 272.802237569653, Press = 0.666110466445508
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3148.3235     -3148.3235     -3219.358      -3219.358       274.91079      274.91079      44490.09       44490.09       121.84686      121.84686    
     60000  -3145.5077     -3145.5077     -3218.3027     -3218.3027      281.72433      281.72433      44714.493      44714.493     -378.29771     -378.29771    
Loop time of 185.851 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.465 ns/day, 51.625 hours/ns, 5.381 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 184.81     | 184.81     | 184.81     |   0.0 | 99.44
Neigh   | 0.49458    | 0.49458    | 0.49458    |   0.0 |  0.27
Comm    | 0.096813   | 0.096813   | 0.096813   |   0.0 |  0.05
Output  | 0.00016617 | 0.00016617 | 0.00016617 |   0.0 |  0.00
Modify  | 0.39423    | 0.39423    | 0.39423    |   0.0 |  0.21
Other   |            | 0.05693    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3341 ave        3341 max        3341 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120720 ave      120720 max      120720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120720
Ave neighs/atom = 60.36
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 = 272.830194279381, Press = 0.0158433879516036
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3145.5077     -3145.5077     -3218.3027     -3218.3027      281.72433      281.72433      44714.493      44714.493     -378.29771     -378.29771    
     61000  -3147.9363     -3147.9363     -3219.7356     -3219.7356      277.87051      277.87051      44324.262      44324.262      573.10949      573.10949    
Loop time of 199.068 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.434 ns/day, 55.297 hours/ns, 5.023 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.98     | 197.98     | 197.98     |   0.0 | 99.45
Neigh   | 0.49039    | 0.49039    | 0.49039    |   0.0 |  0.25
Comm    | 0.10239    | 0.10239    | 0.10239    |   0.0 |  0.05
Output  | 0.00022662 | 0.00022662 | 0.00022662 |   0.0 |  0.00
Modify  | 0.43485    | 0.43485    | 0.43485    |   0.0 |  0.22
Other   |            | 0.06024    |            |       |  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:       121074 ave      121074 max      121074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121074
Ave neighs/atom = 60.537
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.852114689209, Press = 0.491921919867983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3147.9363     -3147.9363     -3219.7356     -3219.7356      277.87051      277.87051      44324.262      44324.262      573.10949      573.10949    
     62000  -3148.815      -3148.815      -3218.0002     -3218.0002      267.75379      267.75379      44702.973      44702.973     -477.10711     -477.10711    
Loop time of 205.121 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 56.978 hours/ns, 4.875 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.99     | 203.99     | 203.99     |   0.0 | 99.45
Neigh   | 0.51921    | 0.51921    | 0.51921    |   0.0 |  0.25
Comm    | 0.10559    | 0.10559    | 0.10559    |   0.0 |  0.05
Output  | 0.00016824 | 0.00016824 | 0.00016824 |   0.0 |  0.00
Modify  | 0.44973    | 0.44973    | 0.44973    |   0.0 |  0.22
Other   |            | 0.06055    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3312 ave        3312 max        3312 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120890 ave      120890 max      120890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120890
Ave neighs/atom = 60.445
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 = 272.86379102189, Press = 0.710636289377757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     62000  -3148.815      -3148.815      -3218.0002     -3218.0002      267.75379      267.75379      44702.973      44702.973     -477.10711     -477.10711    
     63000  -3148.5424     -3148.5424     -3219.3329     -3219.3329      273.96661      273.96661      44575.724      44575.724     -95.159163     -95.159163    
Loop time of 205.589 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.420 ns/day, 57.108 hours/ns, 4.864 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    | 204.44     | 204.44     | 204.44     |   0.0 | 99.44
Neigh   | 0.53251    | 0.53251    | 0.53251    |   0.0 |  0.26
Comm    | 0.10548    | 0.10548    | 0.10548    |   0.0 |  0.05
Output  | 0.00021522 | 0.00021522 | 0.00021522 |   0.0 |  0.00
Modify  | 0.44941    | 0.44941    | 0.44941    |   0.0 |  0.22
Other   |            | 0.06027    |            |       |  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:       120900 ave      120900 max      120900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120900
Ave neighs/atom = 60.45
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 = 272.870754043039, Press = -0.103250890902011
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     63000  -3148.5424     -3148.5424     -3219.3329     -3219.3329      273.96661      273.96661      44575.724      44575.724     -95.159163     -95.159163    
     64000  -3145.8629     -3145.8629     -3218.6942     -3218.6942      281.86454      281.86454      44504.849      44504.849      161.2629       161.2629     
Loop time of 175.217 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.671 hours/ns, 5.707 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.25     | 174.25     | 174.25     |   0.0 | 99.45
Neigh   | 0.45558    | 0.45558    | 0.45558    |   0.0 |  0.26
Comm    | 0.09073    | 0.09073    | 0.09073    |   0.0 |  0.05
Output  | 0.00020825 | 0.00020825 | 0.00020825 |   0.0 |  0.00
Modify  | 0.36231    | 0.36231    | 0.36231    |   0.0 |  0.21
Other   |            | 0.05508    |            |       |  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:       121276 ave      121276 max      121276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121276
Ave neighs/atom = 60.638
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.893286708928, Press = 0.496626861385884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3145.8629     -3145.8629     -3218.6942     -3218.6942      281.86454      281.86454      44504.849      44504.849      161.2629       161.2629     
     65000  -3148.4291     -3148.4291     -3218.2157     -3218.2157      270.08131      270.08131      44619.731      44619.731     -237.12343     -237.12343    
Loop time of 174.479 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.467 hours/ns, 5.731 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.52     | 173.52     | 173.52     |   0.0 | 99.45
Neigh   | 0.45585    | 0.45585    | 0.45585    |   0.0 |  0.26
Comm    | 0.090362   | 0.090362   | 0.090362   |   0.0 |  0.05
Output  | 0.00016819 | 0.00016819 | 0.00016819 |   0.0 |  0.00
Modify  | 0.3596     | 0.3596     | 0.3596     |   0.0 |  0.21
Other   |            | 0.05514    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3286 ave        3286 max        3286 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120962 ave      120962 max      120962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120962
Ave neighs/atom = 60.481
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.889165964367, Press = 0.407284898924107
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     65000  -3148.4291     -3148.4291     -3218.2157     -3218.2157      270.08131      270.08131      44619.731      44619.731     -237.12343     -237.12343    
     66000  -3149.3064     -3149.3064     -3219.427      -3219.427       271.37383      271.37383      44567.784      44567.784     -115.74572     -115.74572    
Loop time of 174.2 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.389 hours/ns, 5.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.22     | 173.22     | 173.22     |   0.0 | 99.44
Neigh   | 0.47729    | 0.47729    | 0.47729    |   0.0 |  0.27
Comm    | 0.090677   | 0.090677   | 0.090677   |   0.0 |  0.05
Output  | 0.00016734 | 0.00016734 | 0.00016734 |   0.0 |  0.00
Modify  | 0.35941    | 0.35941    | 0.35941    |   0.0 |  0.21
Other   |            | 0.05527    |            |       |  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:       120806 ave      120806 max      120806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120806
Ave neighs/atom = 60.403
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 = 272.928860632552, Press = -0.262331421639472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -3149.3064     -3149.3064     -3219.427      -3219.427       271.37383      271.37383      44567.784      44567.784     -115.74572     -115.74572    
     67000  -3145.4965     -3145.4965     -3219.3845     -3219.3845      285.95415      285.95415      44325.08       44325.08       618.30031      618.30031    
Loop time of 174.382 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.439 hours/ns, 5.735 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.4      | 173.4      | 173.4      |   0.0 | 99.44
Neigh   | 0.47709    | 0.47709    | 0.47709    |   0.0 |  0.27
Comm    | 0.090276   | 0.090276   | 0.090276   |   0.0 |  0.05
Output  | 0.00016759 | 0.00016759 | 0.00016759 |   0.0 |  0.00
Modify  | 0.35938    | 0.35938    | 0.35938    |   0.0 |  0.21
Other   |            | 0.05524    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3292 ave        3292 max        3292 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121284 ave      121284 max      121284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121284
Ave neighs/atom = 60.642
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 = 272.947338549693, Press = 0.381432919211254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     67000  -3145.4965     -3145.4965     -3219.3845     -3219.3845      285.95415      285.95415      44325.08       44325.08       618.30031      618.30031    
     68000  -3147.8903     -3147.8903     -3218.8309     -3218.8309      274.54764      274.54764      44716.078      44716.078     -527.55141     -527.55141    
Loop time of 174.984 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.607 hours/ns, 5.715 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.98     | 173.98     | 173.98     |   0.0 | 99.42
Neigh   | 0.50108    | 0.50108    | 0.50108    |   0.0 |  0.29
Comm    | 0.091536   | 0.091536   | 0.091536   |   0.0 |  0.05
Output  | 0.00016765 | 0.00016765 | 0.00016765 |   0.0 |  0.00
Modify  | 0.35857    | 0.35857    | 0.35857    |   0.0 |  0.20
Other   |            | 0.05501    |            |       |  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:       120976 ave      120976 max      120976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120976
Ave neighs/atom = 60.488
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 = 272.960936430972, Press = 1.02147662033535
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     68000  -3147.8903     -3147.8903     -3218.8309     -3218.8309      274.54764      274.54764      44716.078      44716.078     -527.55141     -527.55141    
     69000  -3149.3876     -3149.3876     -3219.8762     -3219.8762      272.79794      272.79794      44560.179      44560.179     -91.343049     -91.343049    
Loop time of 174.16 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.378 hours/ns, 5.742 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.2      | 173.2      | 173.2      |   0.0 | 99.45
Neigh   | 0.4561     | 0.4561     | 0.4561     |   0.0 |  0.26
Comm    | 0.090597   | 0.090597   | 0.090597   |   0.0 |  0.05
Output  | 0.00016743 | 0.00016743 | 0.00016743 |   0.0 |  0.00
Modify  | 0.35789    | 0.35789    | 0.35789    |   0.0 |  0.21
Other   |            | 0.05483    |            |       |  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:       120850 ave      120850 max      120850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0