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

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

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

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

kim_interactions Ca

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

kim interactions Ca
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JangSeolLee_2019_CaZnMg__MO_708495328010_002
pair_coeff * * Ca
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 40.078

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 173786.579609503 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_708495328010_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.143 | 4.143 | 4.143 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -7198.1292     -7198.1292     -7360          -7360           313.15         313.15         173786.58      173786.58      994.88013      994.88013    
      1000  -7048.0713     -7048.0713     -7214.6045     -7214.6045      322.16972      322.16972      178353.12      178353.12     -255.47115     -255.47115    
Loop time of 198.372 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.103 hours/ns, 5.041 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    | 197.24     | 197.24     | 197.24     |   0.0 | 99.43
Neigh   | 0.27702    | 0.27702    | 0.27702    |   0.0 |  0.14
Comm    | 0.11307    | 0.11307    | 0.11307    |   0.0 |  0.06
Output  | 0.00024777 | 0.00024777 | 0.00024777 |   0.0 |  0.00
Modify  | 0.65325    | 0.65325    | 0.65325    |   0.0 |  0.33
Other   |            | 0.09029    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195040 ave      195040 max      195040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195040
Ave neighs/atom = 48.76
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -7048.0713     -7048.0713     -7214.6045     -7214.6045      322.16972      322.16972      178353.12      178353.12     -255.47115     -255.47115    
      2000  -7050.8347     -7050.8347     -7209.6261     -7209.6261      307.19281      307.19281      178138.22      178138.22     -19.835309     -19.835309    
Loop time of 218.025 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.562 hours/ns, 4.587 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    | 216.73     | 216.73     | 216.73     |   0.0 | 99.41
Neigh   | 0.32429    | 0.32429    | 0.32429    |   0.0 |  0.15
Comm    | 0.1188     | 0.1188     | 0.1188     |   0.0 |  0.05
Output  | 0.00023465 | 0.00023465 | 0.00023465 |   0.0 |  0.00
Modify  | 0.75349    | 0.75349    | 0.75349    |   0.0 |  0.35
Other   |            | 0.09672    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195686 ave      195686 max      195686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195686
Ave neighs/atom = 48.9215
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -7050.8347     -7050.8347     -7209.6261     -7209.6261      307.19281      307.19281      178138.22      178138.22     -19.835309     -19.835309    
      3000  -7057.7265     -7057.7265     -7212.7393     -7212.7393      299.88281      299.88281      177871.48      177871.48      179.49079      179.49079    
Loop time of 196.636 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.621 hours/ns, 5.086 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    | 195.49     | 195.49     | 195.49     |   0.0 | 99.42
Neigh   | 0.30831    | 0.30831    | 0.30831    |   0.0 |  0.16
Comm    | 0.108      | 0.108      | 0.108      |   0.0 |  0.05
Output  | 0.00023279 | 0.00023279 | 0.00023279 |   0.0 |  0.00
Modify  | 0.64222    | 0.64222    | 0.64222    |   0.0 |  0.33
Other   |            | 0.09066    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196030 ave      196030 max      196030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196030
Ave neighs/atom = 49.0075
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -7057.7265     -7057.7265     -7212.7393     -7212.7393      299.88281      299.88281      177871.48      177871.48      179.49079      179.49079    
      4000  -7044.9643     -7044.9643     -7211.0757     -7211.0757      321.35394      321.35394      178202.46      178202.46     -53.277059     -53.277059    
Loop time of 196.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.606 hours/ns, 5.087 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    | 195.47     | 195.47     | 195.47     |   0.0 | 99.43
Neigh   | 0.2741     | 0.2741     | 0.2741     |   0.0 |  0.14
Comm    | 0.10694    | 0.10694    | 0.10694    |   0.0 |  0.05
Output  | 0.00023414 | 0.00023414 | 0.00023414 |   0.0 |  0.00
Modify  | 0.64216    | 0.64216    | 0.64216    |   0.0 |  0.33
Other   |            | 0.09105    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195570 ave      195570 max      195570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195570
Ave neighs/atom = 48.8925
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -7044.9643     -7044.9643     -7211.0757     -7211.0757      321.35394      321.35394      178202.46      178202.46     -53.277059     -53.277059    
      5000  -7054.1359     -7054.1359     -7221.1719     -7221.1719      323.14246      323.14246      177945.55      177945.55     -10.604505     -10.604505    
Loop time of 203.822 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.617 hours/ns, 4.906 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    | 202.62     | 202.62     | 202.62     |   0.0 | 99.41
Neigh   | 0.31205    | 0.31205    | 0.31205    |   0.0 |  0.15
Comm    | 0.11137    | 0.11137    | 0.11137    |   0.0 |  0.05
Output  | 0.00022742 | 0.00022742 | 0.00022742 |   0.0 |  0.00
Modify  | 0.68185    | 0.68185    | 0.68185    |   0.0 |  0.33
Other   |            | 0.09185    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195902 ave      195902 max      195902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195902
Ave neighs/atom = 48.9755
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.397161693988, Press = 41.0759922226218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -7054.1359     -7054.1359     -7221.1719     -7221.1719      323.14246      323.14246      177945.55      177945.55     -10.604505     -10.604505    
      6000  -7048.1403     -7048.1403     -7212.9155     -7212.9155      318.76875      318.76875      178287.76      178287.76     -198.4757      -198.4757     
Loop time of 199.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.494 hours/ns, 5.006 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.58     | 198.58     | 198.58     |   0.0 | 99.40
Neigh   | 0.30963    | 0.30963    | 0.30963    |   0.0 |  0.15
Comm    | 0.11168    | 0.11168    | 0.11168    |   0.0 |  0.06
Output  | 0.00018975 | 0.00018975 | 0.00018975 |   0.0 |  0.00
Modify  | 0.68766    | 0.68766    | 0.68766    |   0.0 |  0.34
Other   |            | 0.0891     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195242 ave      195242 max      195242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195242
Ave neighs/atom = 48.8105
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.741944128377, Press = -0.787920698548126
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -7048.1403     -7048.1403     -7212.9155     -7212.9155      318.76875      318.76875      178287.76      178287.76     -198.4757      -198.4757     
      7000  -7052.0633     -7052.0633     -7212.9329     -7212.9329      311.21311      311.21311      177975.92      177975.92      64.150149      64.150149    
Loop time of 228 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.333 hours/ns, 4.386 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    | 226.6      | 226.6      | 226.6      |   0.0 | 99.39
Neigh   | 0.33117    | 0.33117    | 0.33117    |   0.0 |  0.15
Comm    | 0.12397    | 0.12397    | 0.12397    |   0.0 |  0.05
Output  | 0.00019192 | 0.00019192 | 0.00019192 |   0.0 |  0.00
Modify  | 0.84196    | 0.84196    | 0.84196    |   0.0 |  0.37
Other   |            | 0.09985    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3814 ave        3814 max        3814 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196244 ave      196244 max      196244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196244
Ave neighs/atom = 49.061
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.903952446731, Press = 9.51283319353889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -7052.0633     -7052.0633     -7212.9329     -7212.9329      311.21311      311.21311      177975.92      177975.92      64.150149      64.150149    
      8000  -7048.02       -7048.02       -7213.1271     -7213.1271      319.41084      319.41084      177652.41      177652.41      422.18553      422.18553    
Loop time of 228.212 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.392 hours/ns, 4.382 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    | 226.79     | 226.79     | 226.79     |   0.0 | 99.38
Neigh   | 0.36929    | 0.36929    | 0.36929    |   0.0 |  0.16
Comm    | 0.12458    | 0.12458    | 0.12458    |   0.0 |  0.05
Output  | 0.00019218 | 0.00019218 | 0.00019218 |   0.0 |  0.00
Modify  | 0.83067    | 0.83067    | 0.83067    |   0.0 |  0.36
Other   |            | 0.09856    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195916 ave      195916 max      195916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195916
Ave neighs/atom = 48.979
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.255278973209, Press = -2.11507814214597
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -7048.02       -7048.02       -7213.1271     -7213.1271      319.41084      319.41084      177652.41      177652.41      422.18553      422.18553    
      9000  -7052.8912     -7052.8912     -7215.0299     -7215.0299      313.66849      313.66849      178345.4       178345.4      -324.09343     -324.09343    
Loop time of 228.207 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.391 hours/ns, 4.382 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    | 226.81     | 226.81     | 226.81     |   0.0 | 99.39
Neigh   | 0.33213    | 0.33213    | 0.33213    |   0.0 |  0.15
Comm    | 0.12387    | 0.12387    | 0.12387    |   0.0 |  0.05
Output  | 0.00026707 | 0.00026707 | 0.00026707 |   0.0 |  0.00
Modify  | 0.84309    | 0.84309    | 0.84309    |   0.0 |  0.37
Other   |            | 0.1005     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195606 ave      195606 max      195606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195606
Ave neighs/atom = 48.9015
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.791212548803, Press = -0.0178208133383103
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -7052.8912     -7052.8912     -7215.0299     -7215.0299      313.66849      313.66849      178345.4       178345.4      -324.09343     -324.09343    
     10000  -7059.5813     -7059.5813     -7218.6189     -7218.6189      307.66907      307.66907      177870.76      177870.76      64.405156      64.405156    
Loop time of 224.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.397 hours/ns, 4.452 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    | 223.26     | 223.26     | 223.26     |   0.0 | 99.39
Neigh   | 0.33103    | 0.33103    | 0.33103    |   0.0 |  0.15
Comm    | 0.12227    | 0.12227    | 0.12227    |   0.0 |  0.05
Output  | 0.00018515 | 0.00018515 | 0.00018515 |   0.0 |  0.00
Modify  | 0.81663    | 0.81663    | 0.81663    |   0.0 |  0.36
Other   |            | 0.09894    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195946 ave      195946 max      195946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195946
Ave neighs/atom = 48.9865
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.772247181625, Press = 2.22057901219419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.148 | 4.148 | 4.148 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -7059.5813     -7059.5813     -7218.6189     -7218.6189      307.66907      307.66907      177870.76      177870.76      64.405156      64.405156    
     11000  -7049.7842     -7049.7842     -7214.9885     -7214.9885      319.59892      319.59892      178020.75      178020.75      24.963951      24.963951    
Loop time of 196.448 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.569 hours/ns, 5.090 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    | 195.31     | 195.31     | 195.31     |   0.0 | 99.42
Neigh   | 0.27246    | 0.27246    | 0.27246    |   0.0 |  0.14
Comm    | 0.10788    | 0.10788    | 0.10788    |   0.0 |  0.05
Output  | 0.0001893  | 0.0001893  | 0.0001893  |   0.0 |  0.00
Modify  | 0.66833    | 0.66833    | 0.66833    |   0.0 |  0.34
Other   |            | 0.09012    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3814 ave        3814 max        3814 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195510 ave      195510 max      195510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195510
Ave neighs/atom = 48.8775
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.621691284484, Press = 0.237434161437484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -7049.7842     -7049.7842     -7214.9885     -7214.9885      319.59892      319.59892      178020.75      178020.75      24.963951      24.963951    
     12000  -7050.22       -7050.22       -7213.7637     -7213.7637      316.38644      316.38644      178123.52      178123.52     -71.390439     -71.390439    
Loop time of 201.896 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.082 hours/ns, 4.953 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    | 200.68     | 200.68     | 200.68     |   0.0 | 99.40
Neigh   | 0.3128     | 0.3128     | 0.3128     |   0.0 |  0.15
Comm    | 0.11143    | 0.11143    | 0.11143    |   0.0 |  0.06
Output  | 0.00019145 | 0.00019145 | 0.00019145 |   0.0 |  0.00
Modify  | 0.6985     | 0.6985     | 0.6985     |   0.0 |  0.35
Other   |            | 0.09066    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195604 ave      195604 max      195604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195604
Ave neighs/atom = 48.901
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.828984920759, Press = 0.601767261660446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -7050.22       -7050.22       -7213.7637     -7213.7637      316.38644      316.38644      178123.52      178123.52     -71.390439     -71.390439    
     13000  -7053.0683     -7053.0683     -7214.7948     -7214.7948      312.87076      312.87076      178128.39      178128.39     -74.536433     -74.536433    
Loop time of 228.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.467 hours/ns, 4.377 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    | 227.09     | 227.09     | 227.09     |   0.0 | 99.39
Neigh   | 0.33068    | 0.33068    | 0.33068    |   0.0 |  0.14
Comm    | 0.12391    | 0.12391    | 0.12391    |   0.0 |  0.05
Output  | 0.00024582 | 0.00024582 | 0.00024582 |   0.0 |  0.00
Modify  | 0.837      | 0.837      | 0.837      |   0.0 |  0.37
Other   |            | 0.1014     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3820 ave        3820 max        3820 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195722 ave      195722 max      195722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195722
Ave neighs/atom = 48.9305
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.61383622036, Press = 0.17676282074953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -7053.0683     -7053.0683     -7214.7948     -7214.7948      312.87076      312.87076      178128.39      178128.39     -74.536433     -74.536433    
     14000  -7048.2569     -7048.2569     -7213.2476     -7213.2476      319.18556      319.18556      178314.44      178314.44     -224.70681     -224.70681    
Loop time of 213.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.256 hours/ns, 4.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.03     | 212.03     | 212.03     |   0.0 | 99.39
Neigh   | 0.32123    | 0.32123    | 0.32123    |   0.0 |  0.15
Comm    | 0.11687    | 0.11687    | 0.11687    |   0.0 |  0.05
Output  | 0.00050831 | 0.00050831 | 0.00050831 |   0.0 |  0.00
Modify  | 0.75729    | 0.75729    | 0.75729    |   0.0 |  0.35
Other   |            | 0.09518    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195638 ave      195638 max      195638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195638
Ave neighs/atom = 48.9095
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.551852526761, Press = 1.14490156556226
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -7048.2569     -7048.2569     -7213.2476     -7213.2476      319.18556      319.18556      178314.44      178314.44     -224.70681     -224.70681    
     15000  -7054.4365     -7054.4365     -7215.1477     -7215.1477      310.9067       310.9067       177769.86      177769.86      224.94127      224.94127    
Loop time of 216.457 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.399 ns/day, 60.127 hours/ns, 4.620 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    | 215.14     | 215.14     | 215.14     |   0.0 | 99.39
Neigh   | 0.32079    | 0.32079    | 0.32079    |   0.0 |  0.15
Comm    | 0.11947    | 0.11947    | 0.11947    |   0.0 |  0.06
Output  | 0.00019289 | 0.00019289 | 0.00019289 |   0.0 |  0.00
Modify  | 0.77509    | 0.77509    | 0.77509    |   0.0 |  0.36
Other   |            | 0.09681    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196236 ave      196236 max      196236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196236
Ave neighs/atom = 49.059
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.476098139993, Press = 1.12988888996551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.147 | 4.147 | 4.147 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -7054.4365     -7054.4365     -7215.1477     -7215.1477      310.9067       310.9067       177769.86      177769.86      224.94127      224.94127    
     16000  -7050.9315     -7050.9315     -7211.6667     -7211.6667      310.95325      310.95325      178301.94      178301.94     -223.03974     -223.03974    
Loop time of 227.546 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.207 hours/ns, 4.395 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    | 226.15     | 226.15     | 226.15     |   0.0 | 99.39
Neigh   | 0.3309     | 0.3309     | 0.3309     |   0.0 |  0.15
Comm    | 0.12455    | 0.12455    | 0.12455    |   0.0 |  0.05
Output  | 0.00019215 | 0.00019215 | 0.00019215 |   0.0 |  0.00
Modify  | 0.8368     | 0.8368     | 0.8368     |   0.0 |  0.37
Other   |            | 0.1007     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195910 ave      195910 max      195910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195910
Ave neighs/atom = 48.9775
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.429368728225, Press = -0.970944778543298
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -7050.9315     -7050.9315     -7211.6667     -7211.6667      310.95325      310.95325      178301.94      178301.94     -223.03974     -223.03974    
     17000  -7056.0935     -7056.0935     -7214.6763     -7214.6763      306.7892       306.7892       178088.09      178088.09     -51.371696     -51.371696    
Loop time of 229.121 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.645 hours/ns, 4.365 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    | 227.73     | 227.73     | 227.73     |   0.0 | 99.39
Neigh   | 0.33148    | 0.33148    | 0.33148    |   0.0 |  0.14
Comm    | 0.12253    | 0.12253    | 0.12253    |   0.0 |  0.05
Output  | 0.00019106 | 0.00019106 | 0.00019106 |   0.0 |  0.00
Modify  | 0.83386    | 0.83386    | 0.83386    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3820 ave        3820 max        3820 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196294 ave      196294 max      196294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196294
Ave neighs/atom = 49.0735
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.468496487413, Press = 1.71335142047321
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -7056.0935     -7056.0935     -7214.6763     -7214.6763      306.7892       306.7892       178088.09      178088.09     -51.371696     -51.371696    
     18000  -7048.3072     -7048.3072     -7213.9747     -7213.9747      320.49516      320.49516      178011.74      178011.74      69.221516      69.221516    
Loop time of 229.144 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.651 hours/ns, 4.364 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    | 227.79     | 227.79     | 227.79     |   0.0 | 99.41
Neigh   | 0.29485    | 0.29485    | 0.29485    |   0.0 |  0.13
Comm    | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.05
Output  | 0.00022622 | 0.00022622 | 0.00022622 |   0.0 |  0.00
Modify  | 0.83945    | 0.83945    | 0.83945    |   0.0 |  0.37
Other   |            | 0.1011     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195432 ave      195432 max      195432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195432
Ave neighs/atom = 48.858
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.501941848898, Press = 0.222923119955939
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -7048.3072     -7048.3072     -7213.9747     -7213.9747      320.49516      320.49516      178011.74      178011.74      69.221516      69.221516    
     19000  -7054.993      -7054.993      -7216.1804     -7216.1804      311.82779      311.82779      178156.37      178156.37     -151.9003      -151.9003     
Loop time of 229.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.615 hours/ns, 4.367 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    | 227.62     | 227.62     | 227.62     |   0.0 | 99.39
Neigh   | 0.32958    | 0.32958    | 0.32958    |   0.0 |  0.14
Comm    | 0.12478    | 0.12478    | 0.12478    |   0.0 |  0.05
Output  | 0.00019052 | 0.00019052 | 0.00019052 |   0.0 |  0.00
Modify  | 0.83981    | 0.83981    | 0.83981    |   0.0 |  0.37
Other   |            | 0.1017     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195452 ave      195452 max      195452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195452
Ave neighs/atom = 48.863
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.516475693289, Press = -0.0828907370743246
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -7054.993      -7054.993      -7216.1804     -7216.1804      311.82779      311.82779      178156.37      178156.37     -151.9003      -151.9003     
     20000  -7049.3928     -7049.3928     -7212.6002     -7212.6002      315.7358       315.7358       178096.05      178096.05     -11.431579     -11.431579    
Loop time of 205.182 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.995 hours/ns, 4.874 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.94     | 203.94     | 203.94     |   0.0 | 99.40
Neigh   | 0.31221    | 0.31221    | 0.31221    |   0.0 |  0.15
Comm    | 0.11248    | 0.11248    | 0.11248    |   0.0 |  0.05
Output  | 0.00019016 | 0.00019016 | 0.00019016 |   0.0 |  0.00
Modify  | 0.71974    | 0.71974    | 0.71974    |   0.0 |  0.35
Other   |            | 0.09491    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195886 ave      195886 max      195886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195886
Ave neighs/atom = 48.9715
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.415301719427, Press = 0.651964760249236
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -7049.3928     -7049.3928     -7212.6002     -7212.6002      315.7358       315.7358       178096.05      178096.05     -11.431579     -11.431579    
     21000  -7055.2434     -7055.2434     -7217.5799     -7217.5799      314.051        314.051        177750.18      177750.18      219.13259      219.13259    
Loop time of 210.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.401 hours/ns, 4.756 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    | 208.97     | 208.97     | 208.97     |   0.0 | 99.39
Neigh   | 0.31678    | 0.31678    | 0.31678    |   0.0 |  0.15
Comm    | 0.11499    | 0.11499    | 0.11499    |   0.0 |  0.05
Output  | 0.00019262 | 0.00019262 | 0.00019262 |   0.0 |  0.00
Modify  | 0.74466    | 0.74466    | 0.74466    |   0.0 |  0.35
Other   |            | 0.09647    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196068 ave      196068 max      196068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196068
Ave neighs/atom = 49.017
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.36575186927, Press = 0.240813598927341
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -7055.2434     -7055.2434     -7217.5799     -7217.5799      314.051        314.051        177750.18      177750.18      219.13259      219.13259    
     22000  -7052.89       -7052.89       -7212.2316     -7212.2316      308.2571       308.2571       178366.28      178366.28     -300.95854     -300.95854    
Loop time of 217.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.530 hours/ns, 4.589 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    | 216.59     | 216.59     | 216.59     |   0.0 | 99.39
Neigh   | 0.3224     | 0.3224     | 0.3224     |   0.0 |  0.15
Comm    | 0.11761    | 0.11761    | 0.11761    |   0.0 |  0.05
Output  | 0.00019073 | 0.00019073 | 0.00019073 |   0.0 |  0.00
Modify  | 0.78143    | 0.78143    | 0.78143    |   0.0 |  0.36
Other   |            | 0.09771    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195828 ave      195828 max      195828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195828
Ave neighs/atom = 48.957
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.440143997837, Press = -0.174222047244233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -7052.89       -7052.89       -7212.2316     -7212.2316      308.2571       308.2571       178366.28      178366.28     -300.95854     -300.95854    
     23000  -7049.1613     -7049.1613     -7210.427      -7210.427       311.97952      311.97952      178111.61      178111.61      5.7510196      5.7510196    
Loop time of 229.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.732 hours/ns, 4.359 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    | 228.04     | 228.04     | 228.04     |   0.0 | 99.39
Neigh   | 0.33284    | 0.33284    | 0.33284    |   0.0 |  0.15
Comm    | 0.12496    | 0.12496    | 0.12496    |   0.0 |  0.05
Output  | 0.00019212 | 0.00019212 | 0.00019212 |   0.0 |  0.00
Modify  | 0.83963    | 0.83963    | 0.83963    |   0.0 |  0.37
Other   |            | 0.1012     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196132 ave      196132 max      196132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196132
Ave neighs/atom = 49.033
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.545552591672, Press = 1.05010985654652
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -7049.1613     -7049.1613     -7210.427      -7210.427       311.97952      311.97952      178111.61      178111.61      5.7510196      5.7510196    
     24000  -7046.8631     -7046.8631     -7212.033      -7212.033       319.53248      319.53248      177923.03      177923.03      186.99416      186.99416    
Loop time of 228.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.508 hours/ns, 4.374 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    | 227.23     | 227.23     | 227.23     |   0.0 | 99.39
Neigh   | 0.33353    | 0.33353    | 0.33353    |   0.0 |  0.15
Comm    | 0.12403    | 0.12403    | 0.12403    |   0.0 |  0.05
Output  | 0.00018922 | 0.00018922 | 0.00018922 |   0.0 |  0.00
Modify  | 0.84209    | 0.84209    | 0.84209    |   0.0 |  0.37
Other   |            | 0.09982    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195362 ave      195362 max      195362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195362
Ave neighs/atom = 48.8405
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.533461546527, Press = -0.0417157653038156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -7046.8631     -7046.8631     -7212.033      -7212.033       319.53248      319.53248      177923.03      177923.03      186.99416      186.99416    
     25000  -7055.7586     -7055.7586     -7215.0364     -7215.0364      308.13371      308.13371      178129.98      178129.98     -106.72872     -106.72872    
Loop time of 229.112 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.642 hours/ns, 4.365 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    | 227.71     | 227.71     | 227.71     |   0.0 | 99.39
Neigh   | 0.3323     | 0.3323     | 0.3323     |   0.0 |  0.15
Comm    | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.05
Output  | 0.00019193 | 0.00019193 | 0.00019193 |   0.0 |  0.00
Modify  | 0.83828    | 0.83828    | 0.83828    |   0.0 |  0.37
Other   |            | 0.1013     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195786 ave      195786 max      195786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195786
Ave neighs/atom = 48.9465
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.518097926536, Press = 0.00498672694691696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -7055.7586     -7055.7586     -7215.0364     -7215.0364      308.13371      308.13371      178129.98      178129.98     -106.72872     -106.72872    
     26000  -7050.2317     -7050.2317     -7211.4407     -7211.4407      311.86973      311.86973      178176.13      178176.13     -68.531513     -68.531513    
Loop time of 229.398 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.722 hours/ns, 4.359 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    | 228        | 228        | 228        |   0.0 | 99.39
Neigh   | 0.33278    | 0.33278    | 0.33278    |   0.0 |  0.15
Comm    | 0.12638    | 0.12638    | 0.12638    |   0.0 |  0.06
Output  | 0.00023419 | 0.00023419 | 0.00023419 |   0.0 |  0.00
Modify  | 0.84103    | 0.84103    | 0.84103    |   0.0 |  0.37
Other   |            | 0.1016     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195500 ave      195500 max      195500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195500
Ave neighs/atom = 48.875
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.458932841628, Press = 0.338856507983155
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -7050.2317     -7050.2317     -7211.4407     -7211.4407      311.86973      311.86973      178176.13      178176.13     -68.531513     -68.531513    
     27000  -7053.9324     -7053.9324     -7216.5448     -7216.5448      314.58466      314.58466      177933.36      177933.36      63.43215       63.43215     
Loop time of 229.362 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.712 hours/ns, 4.360 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    | 227.96     | 227.96     | 227.96     |   0.0 | 99.39
Neigh   | 0.33257    | 0.33257    | 0.33257    |   0.0 |  0.14
Comm    | 0.12489    | 0.12489    | 0.12489    |   0.0 |  0.05
Output  | 0.00025074 | 0.00025074 | 0.00025074 |   0.0 |  0.00
Modify  | 0.83888    | 0.83888    | 0.83888    |   0.0 |  0.37
Other   |            | 0.1012     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195932 ave      195932 max      195932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195932
Ave neighs/atom = 48.983
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.423893301008, Press = 0.0842469310606938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -7053.9324     -7053.9324     -7216.5448     -7216.5448      314.58466      314.58466      177933.36      177933.36      63.43215       63.43215     
     28000  -7055.1523     -7055.1523     -7217.3744     -7217.3744      313.82973      313.82973      178095.05      178095.05     -120.11519     -120.11519    
Loop time of 229.325 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.701 hours/ns, 4.361 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    | 227.93     | 227.93     | 227.93     |   0.0 | 99.39
Neigh   | 0.33144    | 0.33144    | 0.33144    |   0.0 |  0.14
Comm    | 0.12492    | 0.12492    | 0.12492    |   0.0 |  0.05
Output  | 0.00019131 | 0.00019131 | 0.00019131 |   0.0 |  0.00
Modify  | 0.84225    | 0.84225    | 0.84225    |   0.0 |  0.37
Other   |            | 0.1003     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195612 ave      195612 max      195612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195612
Ave neighs/atom = 48.903
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.473078582248, Press = -0.0600937689753401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -7055.1523     -7055.1523     -7217.3744     -7217.3744      313.82973      313.82973      178095.05      178095.05     -120.11519     -120.11519    
     29000  -7049.5641     -7049.5641     -7210.521      -7210.521       311.38201      311.38201      178040.72      178040.72      73.757086      73.757086    
Loop time of 213.556 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.321 hours/ns, 4.683 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.26     | 212.26     | 212.26     |   0.0 | 99.39
Neigh   | 0.32036    | 0.32036    | 0.32036    |   0.0 |  0.15
Comm    | 0.11531    | 0.11531    | 0.11531    |   0.0 |  0.05
Output  | 0.00019183 | 0.00019183 | 0.00019183 |   0.0 |  0.00
Modify  | 0.76068    | 0.76068    | 0.76068    |   0.0 |  0.36
Other   |            | 0.09591    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195922 ave      195922 max      195922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195922
Ave neighs/atom = 48.9805
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.410751643472, Press = 0.551465365627071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -7049.5641     -7049.5641     -7210.521      -7210.521       311.38201      311.38201      178040.72      178040.72      73.757086      73.757086    
     30000  -7053.4817     -7053.4817     -7213.9133     -7213.9133      310.36573      310.36573      177915.83      177915.83      119.50575      119.50575    
Loop time of 227.315 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.143 hours/ns, 4.399 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    | 225.93     | 225.93     | 225.93     |   0.0 | 99.39
Neigh   | 0.33013    | 0.33013    | 0.33013    |   0.0 |  0.15
Comm    | 0.12247    | 0.12247    | 0.12247    |   0.0 |  0.05
Output  | 0.00019236 | 0.00019236 | 0.00019236 |   0.0 |  0.00
Modify  | 0.83575    | 0.83575    | 0.83575    |   0.0 |  0.37
Other   |            | 0.1006     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195816 ave      195816 max      195816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195816
Ave neighs/atom = 48.954
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.43332578674, Press = -0.274477038089176
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -7053.4817     -7053.4817     -7213.9133     -7213.9133      310.36573      310.36573      177915.83      177915.83      119.50575      119.50575    
     31000  -7051.4529     -7051.4529     -7214.1553     -7214.1553      314.75892      314.75892      178332.08      178332.08     -296.82092     -296.82092    
Loop time of 227.215 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.115 hours/ns, 4.401 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    | 225.83     | 225.83     | 225.83     |   0.0 | 99.39
Neigh   | 0.33041    | 0.33041    | 0.33041    |   0.0 |  0.15
Comm    | 0.12251    | 0.12251    | 0.12251    |   0.0 |  0.05
Output  | 0.00019285 | 0.00019285 | 0.00019285 |   0.0 |  0.00
Modify  | 0.83196    | 0.83196    | 0.83196    |   0.0 |  0.37
Other   |            | 0.101      |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195836 ave      195836 max      195836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195836
Ave neighs/atom = 48.959
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.406302409339, Press = 0.340877681716326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -7051.4529     -7051.4529     -7214.1553     -7214.1553      314.75892      314.75892      178332.08      178332.08     -296.82092     -296.82092    
     32000  -7044.6108     -7044.6108     -7208.2248     -7208.2248      316.52233      316.52233      177953.71      177953.71      220.1113       220.1113     
Loop time of 227.38 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.161 hours/ns, 4.398 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    | 225.98     | 225.98     | 225.98     |   0.0 | 99.38
Neigh   | 0.32918    | 0.32918    | 0.32918    |   0.0 |  0.14
Comm    | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.05
Output  | 0.0002404  | 0.0002404  | 0.0002404  |   0.0 |  0.00
Modify  | 0.84569    | 0.84569    | 0.84569    |   0.0 |  0.37
Other   |            | 0.101      |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195752 ave      195752 max      195752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195752
Ave neighs/atom = 48.938
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.502048540353, Press = 0.373961553382937
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -7044.6108     -7044.6108     -7208.2248     -7208.2248      316.52233      316.52233      177953.71      177953.71      220.1113       220.1113     
     33000  -7050.5707     -7050.5707     -7212.1587     -7212.1587      312.60284      312.60284      178048.31      178048.31      21.551034      21.551034    
Loop time of 227.344 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.151 hours/ns, 4.399 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    | 225.96     | 225.96     | 225.96     |   0.0 | 99.39
Neigh   | 0.32947    | 0.32947    | 0.32947    |   0.0 |  0.14
Comm    | 0.12045    | 0.12045    | 0.12045    |   0.0 |  0.05
Output  | 0.00019196 | 0.00019196 | 0.00019196 |   0.0 |  0.00
Modify  | 0.8321     | 0.8321     | 0.8321     |   0.0 |  0.37
Other   |            | 0.1009     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195540 ave      195540 max      195540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195540
Ave neighs/atom = 48.885
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.554809638137, Press = -0.393348838484209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -7050.5707     -7050.5707     -7212.1587     -7212.1587      312.60284      312.60284      178048.31      178048.31      21.551034      21.551034    
     34000  -7054.9703     -7054.9703     -7215.1842     -7215.1842      309.94475      309.94475      178316.72      178316.72     -268.89684     -268.89684    
Loop time of 214.315 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.403 ns/day, 59.532 hours/ns, 4.666 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    | 212.98     | 212.98     | 212.98     |   0.0 | 99.38
Neigh   | 0.35663    | 0.35663    | 0.35663    |   0.0 |  0.17
Comm    | 0.11616    | 0.11616    | 0.11616    |   0.0 |  0.05
Output  | 0.00023276 | 0.00023276 | 0.00023276 |   0.0 |  0.00
Modify  | 0.76529    | 0.76529    | 0.76529    |   0.0 |  0.36
Other   |            | 0.09696    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195674 ave      195674 max      195674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195674
Ave neighs/atom = 48.9185
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.560503109643, Press = 0.223347309205633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -7054.9703     -7054.9703     -7215.1842     -7215.1842      309.94475      309.94475      178316.72      178316.72     -268.89684     -268.89684    
     35000  -7047.8793     -7047.8793     -7210.848      -7210.848       315.27399      315.27399      178079.45      178079.45      66.330147      66.330147    
Loop time of 220.248 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.180 hours/ns, 4.540 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    | 218.91     | 218.91     | 218.91     |   0.0 | 99.39
Neigh   | 0.32562    | 0.32562    | 0.32562    |   0.0 |  0.15
Comm    | 0.11839    | 0.11839    | 0.11839    |   0.0 |  0.05
Output  | 0.00019021 | 0.00019021 | 0.00019021 |   0.0 |  0.00
Modify  | 0.79922    | 0.79922    | 0.79922    |   0.0 |  0.36
Other   |            | 0.09737    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195642 ave      195642 max      195642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195642
Ave neighs/atom = 48.9105
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.542065037949, Press = 0.306046709390465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -7047.8793     -7047.8793     -7210.848      -7210.848       315.27399      315.27399      178079.45      178079.45      66.330147      66.330147    
     36000  -7053.231      -7053.231      -7214.6498     -7214.6498      312.27572      312.27572      177974.27      177974.27      94.000227      94.000227    
Loop time of 195.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.361 hours/ns, 5.110 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    | 194.53     | 194.53     | 194.53     |   0.0 | 99.40
Neigh   | 0.30775    | 0.30775    | 0.30775    |   0.0 |  0.16
Comm    | 0.10711    | 0.10711    | 0.10711    |   0.0 |  0.05
Output  | 0.00023445 | 0.00023445 | 0.00023445 |   0.0 |  0.00
Modify  | 0.66675    | 0.66675    | 0.66675    |   0.0 |  0.34
Other   |            | 0.08977    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195722 ave      195722 max      195722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195722
Ave neighs/atom = 48.9305
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.545545571629, Press = 0.0593967803704916
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -7053.231      -7053.231      -7214.6498     -7214.6498      312.27572      312.27572      177974.27      177974.27      94.000227      94.000227    
     37000  -7051.6412     -7051.6412     -7211.8973     -7211.8973      310.02617      310.02617      178130.4       178130.4      -44.105245     -44.105245    
Loop time of 204.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.925 hours/ns, 4.880 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.73     | 203.73     | 203.73     |   0.0 | 99.41
Neigh   | 0.28173    | 0.28173    | 0.28173    |   0.0 |  0.14
Comm    | 0.11022    | 0.11022    | 0.11022    |   0.0 |  0.05
Output  | 0.00029453 | 0.00029453 | 0.00029453 |   0.0 |  0.00
Modify  | 0.71409    | 0.71409    | 0.71409    |   0.0 |  0.35
Other   |            | 0.09278    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195618 ave      195618 max      195618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195618
Ave neighs/atom = 48.9045
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.546039811559, Press = 0.00777257601210051
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -7051.6412     -7051.6412     -7211.8973     -7211.8973      310.02617      310.02617      178130.4       178130.4      -44.105245     -44.105245    
     38000  -7050.9477     -7050.9477     -7211.0347     -7211.0347      309.69909      309.69909      178173.46      178173.46     -36.312675     -36.312675    
Loop time of 228.691 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.525 hours/ns, 4.373 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    | 227.31     | 227.31     | 227.31     |   0.0 | 99.40
Neigh   | 0.29591    | 0.29591    | 0.29591    |   0.0 |  0.13
Comm    | 0.12439    | 0.12439    | 0.12439    |   0.0 |  0.05
Output  | 0.00036859 | 0.00036859 | 0.00036859 |   0.0 |  0.00
Modify  | 0.8543     | 0.8543     | 0.8543     |   0.0 |  0.37
Other   |            | 0.1017     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195862 ave      195862 max      195862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195862
Ave neighs/atom = 48.9655
Neighbor list builds = 8
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.556520872674, Press = 0.368083451573429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -7050.9477     -7050.9477     -7211.0347     -7211.0347      309.69909      309.69909      178173.46      178173.46     -36.312675     -36.312675    
     39000  -7045.8895     -7045.8895     -7212.0645     -7212.0645      321.47679      321.47679      177859.54      177859.54      272.84447      272.84447    
Loop time of 222.249 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.736 hours/ns, 4.499 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    | 220.85     | 220.85     | 220.85     |   0.0 | 99.37
Neigh   | 0.36189    | 0.36189    | 0.36189    |   0.0 |  0.16
Comm    | 0.12189    | 0.12189    | 0.12189    |   0.0 |  0.05
Output  | 0.0002447  | 0.0002447  | 0.0002447  |   0.0 |  0.00
Modify  | 0.81411    | 0.81411    | 0.81411    |   0.0 |  0.37
Other   |            | 0.09866    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195966 ave      195966 max      195966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195966
Ave neighs/atom = 48.9915
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.593064249123, Press = 0.0695828844061183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -7045.8895     -7045.8895     -7212.0645     -7212.0645      321.47679      321.47679      177859.54      177859.54      272.84447      272.84447    
     40000  -7050.8464     -7050.8464     -7214.4057     -7214.4057      316.41651      316.41651      178307.13      178307.13     -227.02978     -227.02978    
Loop time of 220.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.359 hours/ns, 4.527 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    | 219.54     | 219.54     | 219.54     |   0.0 | 99.39
Neigh   | 0.33047    | 0.33047    | 0.33047    |   0.0 |  0.15
Comm    | 0.11994    | 0.11994    | 0.11994    |   0.0 |  0.05
Output  | 0.00018915 | 0.00018915 | 0.00018915 |   0.0 |  0.00
Modify  | 0.80381    | 0.80381    | 0.80381    |   0.0 |  0.36
Other   |            | 0.09772    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195138 ave      195138 max      195138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195138
Ave neighs/atom = 48.7845
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.64402811422, Press = -0.270599945931839
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -7050.8464     -7050.8464     -7214.4057     -7214.4057      316.41651      316.41651      178307.13      178307.13     -227.02978     -227.02978    
     41000  -7050.4508     -7050.4508     -7213.6516     -7213.6516      315.72285      315.72285      178167.38      178167.38     -79.192773     -79.192773    
Loop time of 194.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.965 hours/ns, 5.147 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    | 193.11     | 193.11     | 193.11     |   0.0 | 99.40
Neigh   | 0.30529    | 0.30529    | 0.30529    |   0.0 |  0.16
Comm    | 0.10665    | 0.10665    | 0.10665    |   0.0 |  0.05
Output  | 0.00019057 | 0.00019057 | 0.00019057 |   0.0 |  0.00
Modify  | 0.66413    | 0.66413    | 0.66413    |   0.0 |  0.34
Other   |            | 0.09155    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195820 ave      195820 max      195820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195820
Ave neighs/atom = 48.955
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.68787019321, Press = 0.340814962800042
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -7050.4508     -7050.4508     -7213.6516     -7213.6516      315.72285      315.72285      178167.38      178167.38     -79.192773     -79.192773    
     42000  -7046.1982     -7046.1982     -7209.3375     -7209.3375      315.60409      315.60409      177947.25      177947.25      204.2441       204.2441     
Loop time of 194.154 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.932 hours/ns, 5.151 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    | 192.99     | 192.99     | 192.99     |   0.0 | 99.40
Neigh   | 0.30563    | 0.30563    | 0.30563    |   0.0 |  0.16
Comm    | 0.10702    | 0.10702    | 0.10702    |   0.0 |  0.06
Output  | 0.00018907 | 0.00018907 | 0.00018907 |   0.0 |  0.00
Modify  | 0.66333    | 0.66333    | 0.66333    |   0.0 |  0.34
Other   |            | 0.09034    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195512 ave      195512 max      195512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195512
Ave neighs/atom = 48.878
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.725571970604, Press = 0.0155754473683827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -7046.1982     -7046.1982     -7209.3375     -7209.3375      315.60409      315.60409      177947.25      177947.25      204.2441       204.2441     
     43000  -7052.4376     -7052.4376     -7212.4214     -7212.4214      309.49944      309.49944      178164.69      178164.69     -91.496537     -91.496537    
Loop time of 194.52 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.033 hours/ns, 5.141 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    | 193.35     | 193.35     | 193.35     |   0.0 | 99.40
Neigh   | 0.30578    | 0.30578    | 0.30578    |   0.0 |  0.16
Comm    | 0.10711    | 0.10711    | 0.10711    |   0.0 |  0.06
Output  | 0.00018953 | 0.00018953 | 0.00018953 |   0.0 |  0.00
Modify  | 0.6659     | 0.6659     | 0.6659     |   0.0 |  0.34
Other   |            | 0.09057    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3820 ave        3820 max        3820 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195630 ave      195630 max      195630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195630
Ave neighs/atom = 48.9075
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.751792091935, Press = -0.116715597063735
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -7052.4376     -7052.4376     -7212.4214     -7212.4214      309.49944      309.49944      178164.69      178164.69     -91.496537     -91.496537    
     44000  -7050.1532     -7050.1532     -7213.3451     -7213.3451      315.70574      315.70574      178261.56      178261.56     -179.67852     -179.67852    
Loop time of 200.685 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.746 hours/ns, 4.983 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    | 199.48     | 199.48     | 199.48     |   0.0 | 99.40
Neigh   | 0.31271    | 0.31271    | 0.31271    |   0.0 |  0.16
Comm    | 0.10976    | 0.10976    | 0.10976    |   0.0 |  0.05
Output  | 0.00018895 | 0.00018895 | 0.00018895 |   0.0 |  0.00
Modify  | 0.69404    | 0.69404    | 0.69404    |   0.0 |  0.35
Other   |            | 0.0927     |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3821 ave        3821 max        3821 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195908 ave      195908 max      195908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195908
Ave neighs/atom = 48.977
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.776836772889, Press = 0.202705838619587
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -7050.1532     -7050.1532     -7213.3451     -7213.3451      315.70574      315.70574      178261.56      178261.56     -179.67852     -179.67852    
     45000  -7047.1335     -7047.1335     -7213.2698     -7213.2698      321.40193      321.40193      177706.73      177706.73      392.70943      392.70943    
Loop time of 228.371 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.437 hours/ns, 4.379 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    | 226.95     | 226.95     | 226.95     |   0.0 | 99.38
Neigh   | 0.36855    | 0.36855    | 0.36855    |   0.0 |  0.16
Comm    | 0.12292    | 0.12292    | 0.12292    |   0.0 |  0.05
Output  | 0.0001931  | 0.0001931  | 0.0001931  |   0.0 |  0.00
Modify  | 0.82859    | 0.82859    | 0.82859    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196146 ave      196146 max      196146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196146
Ave neighs/atom = 49.0365
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.768588915329, Press = 0.19076093708997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.147 | 4.147 | 4.147 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -7047.1335     -7047.1335     -7213.2698     -7213.2698      321.40193      321.40193      177706.73      177706.73      392.70943      392.70943    
     46000  -7050.8866     -7050.8866     -7212.4557     -7212.4557      312.56643      312.56643      178353.05      178353.05     -251.38069     -251.38069    
Loop time of 223.459 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 62.072 hours/ns, 4.475 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    | 222.07     | 222.07     | 222.07     |   0.0 | 99.38
Neigh   | 0.36318    | 0.36318    | 0.36318    |   0.0 |  0.16
Comm    | 0.12171    | 0.12171    | 0.12171    |   0.0 |  0.05
Output  | 0.00023698 | 0.00023698 | 0.00023698 |   0.0 |  0.00
Modify  | 0.80338    | 0.80338    | 0.80338    |   0.0 |  0.36
Other   |            | 0.09803    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195004 ave      195004 max      195004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195004
Ave neighs/atom = 48.751
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.769894501176, Press = -0.341206084695796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -7050.8866     -7050.8866     -7212.4557     -7212.4557      312.56643      312.56643      178353.05      178353.05     -251.38069     -251.38069    
     47000  -7051.3356     -7051.3356     -7213.4731     -7213.4731      313.666        313.666        178130.18      178130.18     -59.714998     -59.714998    
Loop time of 228.824 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.562 hours/ns, 4.370 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    | 227.43     | 227.43     | 227.43     |   0.0 | 99.39
Neigh   | 0.33344    | 0.33344    | 0.33344    |   0.0 |  0.15
Comm    | 0.12413    | 0.12413    | 0.12413    |   0.0 |  0.05
Output  | 0.00024198 | 0.00024198 | 0.00024198 |   0.0 |  0.00
Modify  | 0.84027    | 0.84027    | 0.84027    |   0.0 |  0.37
Other   |            | 0.1009     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196070 ave      196070 max      196070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196070
Ave neighs/atom = 49.0175
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.757618360427, Press = 0.292655658026974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -7051.3356     -7051.3356     -7213.4731     -7213.4731      313.666        313.666        178130.18      178130.18     -59.714998     -59.714998    
     48000  -7047.28       -7047.28       -7209.0135     -7209.0135      312.8844       312.8844       178019.99      178019.99      148.8999       148.8999     
Loop time of 227.769 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.269 hours/ns, 4.390 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    | 226.38     | 226.38     | 226.38     |   0.0 | 99.39
Neigh   | 0.33125    | 0.33125    | 0.33125    |   0.0 |  0.15
Comm    | 0.1265     | 0.1265     | 0.1265     |   0.0 |  0.06
Output  | 0.00019891 | 0.00019891 | 0.00019891 |   0.0 |  0.00
Modify  | 0.83479    | 0.83479    | 0.83479    |   0.0 |  0.37
Other   |            | 0.0999     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3814 ave        3814 max        3814 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195550 ave      195550 max      195550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195550
Ave neighs/atom = 48.8875
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.773441159915, Press = -0.0491186409530476
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -7047.28       -7047.28       -7209.0135     -7209.0135      312.8844       312.8844       178019.99      178019.99      148.8999       148.8999     
     49000  -7052.0955     -7052.0955     -7214.2977     -7214.2977      313.79125      313.79125      178273.42      178273.42     -193.24826     -193.24826    
Loop time of 203.819 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.616 hours/ns, 4.906 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    | 202.59     | 202.59     | 202.59     |   0.0 | 99.39
Neigh   | 0.31227    | 0.31227    | 0.31227    |   0.0 |  0.15
Comm    | 0.11335    | 0.11335    | 0.11335    |   0.0 |  0.06
Output  | 0.00030415 | 0.00030415 | 0.00030415 |   0.0 |  0.00
Modify  | 0.7146     | 0.7146     | 0.7146     |   0.0 |  0.35
Other   |            | 0.09334    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195358 ave      195358 max      195358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195358
Ave neighs/atom = 48.8395
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.806450408324, Press = -0.0346432409946936
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -7052.0955     -7052.0955     -7214.2977     -7214.2977      313.79125      313.79125      178273.42      178273.42     -193.24826     -193.24826    
     50000  -7051.0693     -7051.0693     -7213.3798     -7213.3798      314.00075      314.00075      177938.18      177938.18      108.8526       108.8526     
Loop time of 230.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.099 hours/ns, 4.334 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    | 229.34     | 229.34     | 229.34     |   0.0 | 99.38
Neigh   | 0.33225    | 0.33225    | 0.33225    |   0.0 |  0.14
Comm    | 0.12839    | 0.12839    | 0.12839    |   0.0 |  0.06
Output  | 0.00023989 | 0.00023989 | 0.00023989 |   0.0 |  0.00
Modify  | 0.86033    | 0.86033    | 0.86033    |   0.0 |  0.37
Other   |            | 0.1018     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196036 ave      196036 max      196036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196036
Ave neighs/atom = 49.009
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.827251159789, Press = 0.3321065147212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -7051.0693     -7051.0693     -7213.3798     -7213.3798      314.00075      314.00075      177938.18      177938.18      108.8526       108.8526     
     51000  -7051.9722     -7051.9722     -7209.9889     -7209.9889      305.69402      305.69402      177852.68      177852.68      243.53145      243.53145    
Loop time of 222.114 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.698 hours/ns, 4.502 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    | 220.73     | 220.73     | 220.73     |   0.0 | 99.38
Neigh   | 0.36255    | 0.36255    | 0.36255    |   0.0 |  0.16
Comm    | 0.12124    | 0.12124    | 0.12124    |   0.0 |  0.05
Output  | 0.00019265 | 0.00019265 | 0.00019265 |   0.0 |  0.00
Modify  | 0.8021     | 0.8021     | 0.8021     |   0.0 |  0.36
Other   |            | 0.09808    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195842 ave      195842 max      195842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195842
Ave neighs/atom = 48.9605
Neighbor list builds = 10
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.859356792006, Press = -0.330635661233822
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -7051.9722     -7051.9722     -7209.9889     -7209.9889      305.69402      305.69402      177852.68      177852.68      243.53145      243.53145    
     52000  -7051.8854     -7051.8854     -7210.2394     -7210.2394      306.34647      306.34647      178440.52      178440.52     -318.67251     -318.67251    
Loop time of 215.974 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 59.993 hours/ns, 4.630 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    | 214.66     | 214.66     | 214.66     |   0.0 | 99.39
Neigh   | 0.32514    | 0.32514    | 0.32514    |   0.0 |  0.15
Comm    | 0.11842    | 0.11842    | 0.11842    |   0.0 |  0.05
Output  | 0.00059874 | 0.00059874 | 0.00059874 |   0.0 |  0.00
Modify  | 0.77224    | 0.77224    | 0.77224    |   0.0 |  0.36
Other   |            | 0.09682    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196226 ave      196226 max      196226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196226
Ave neighs/atom = 49.0565
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.861516686396, Press = 0.18255093513846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -7051.8854     -7051.8854     -7210.2394     -7210.2394      306.34647      306.34647      178440.52      178440.52     -318.67251     -318.67251    
     53000  -7050.4306     -7050.4306     -7211.0964     -7211.0964      310.81873      310.81873      177995.22      177995.22      96.500225      96.500225    
Loop time of 214.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.402 ns/day, 59.687 hours/ns, 4.654 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    | 213.57     | 213.57     | 213.57     |   0.0 | 99.39
Neigh   | 0.31836    | 0.31836    | 0.31836    |   0.0 |  0.15
Comm    | 0.11708    | 0.11708    | 0.11708    |   0.0 |  0.05
Output  | 0.00018883 | 0.00018883 | 0.00018883 |   0.0 |  0.00
Modify  | 0.77222    | 0.77222    | 0.77222    |   0.0 |  0.36
Other   |            | 0.09735    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3824 ave        3824 max        3824 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195588 ave      195588 max      195588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195588
Ave neighs/atom = 48.897
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.870483969299, Press = 0.117594439217089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -7050.4306     -7050.4306     -7211.0964     -7211.0964      310.81873      310.81873      177995.22      177995.22      96.500225      96.500225    
     54000  -7053.1681     -7053.1681     -7214.7288     -7214.7288      312.55003      312.55003      178072.6       178072.6      -34.355035     -34.355035    
Loop time of 196.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.572 hours/ns, 5.090 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    | 195.28     | 195.28     | 195.28     |   0.0 | 99.40
Neigh   | 0.30869    | 0.30869    | 0.30869    |   0.0 |  0.16
Comm    | 0.10967    | 0.10967    | 0.10967    |   0.0 |  0.06
Output  | 0.00018994 | 0.00018994 | 0.00018994 |   0.0 |  0.00
Modify  | 0.6769     | 0.6769     | 0.6769     |   0.0 |  0.34
Other   |            | 0.08992    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195626 ave      195626 max      195626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195626
Ave neighs/atom = 48.9065
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.862240758769, Press = -0.024491632664811
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -7053.1681     -7053.1681     -7214.7288     -7214.7288      312.55003      312.55003      178072.6       178072.6      -34.355035     -34.355035    
     55000  -7042.6953     -7042.6953     -7210.3397     -7210.3397      324.31938      324.31938      178218.83      178218.83     -60.312823     -60.312823    
Loop time of 199.747 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.485 hours/ns, 5.006 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.54     | 198.54     | 198.54     |   0.0 | 99.39
Neigh   | 0.31144    | 0.31144    | 0.31144    |   0.0 |  0.16
Comm    | 0.1098     | 0.1098     | 0.1098     |   0.0 |  0.05
Output  | 0.00019114 | 0.00019114 | 0.00019114 |   0.0 |  0.00
Modify  | 0.69537    | 0.69537    | 0.69537    |   0.0 |  0.35
Other   |            | 0.09268    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195446 ave      195446 max      195446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195446
Ave neighs/atom = 48.8615
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.845059919617, Press = 0.0941115815087145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -7042.6953     -7042.6953     -7210.3397     -7210.3397      324.31938      324.31938      178218.83      178218.83     -60.312823     -60.312823    
     56000  -7053.3631     -7053.3631     -7212.7996     -7212.7996      308.44061      308.44061      177859.35      177859.35      195.93246      195.93246    
Loop time of 195.203 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.223 hours/ns, 5.123 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    | 194.03     | 194.03     | 194.03     |   0.0 | 99.40
Neigh   | 0.3069     | 0.3069     | 0.3069     |   0.0 |  0.16
Comm    | 0.10804    | 0.10804    | 0.10804    |   0.0 |  0.06
Output  | 0.0002424  | 0.0002424  | 0.0002424  |   0.0 |  0.00
Modify  | 0.67059    | 0.67059    | 0.67059    |   0.0 |  0.34
Other   |            | 0.09144    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195574 ave      195574 max      195574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195574
Ave neighs/atom = 48.8935
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.876419331625, Press = 0.0484526834254548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -7053.3631     -7053.3631     -7212.7996     -7212.7996      308.44061      308.44061      177859.35      177859.35      195.93246      195.93246    
     57000  -7045.3595     -7045.3595     -7211.3535     -7211.3535      321.12658      321.12658      178513.28      178513.28     -356.86404     -356.86404    
Loop time of 209.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.117 hours/ns, 4.780 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    | 207.95     | 207.95     | 207.95     |   0.0 | 99.39
Neigh   | 0.31739    | 0.31739    | 0.31739    |   0.0 |  0.15
Comm    | 0.11387    | 0.11387    | 0.11387    |   0.0 |  0.05
Output  | 0.0001908  | 0.0001908  | 0.0001908  |   0.0 |  0.00
Modify  | 0.74129    | 0.74129    | 0.74129    |   0.0 |  0.35
Other   |            | 0.09504    |            |       |  0.05

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195240 ave      195240 max      195240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195240
Ave neighs/atom = 48.81
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.922131638143, Press = -0.0812378017545458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -7045.3595     -7045.3595     -7211.3535     -7211.3535      321.12658      321.12658      178513.28      178513.28     -356.86404     -356.86404    
     58000  -7049.0116     -7049.0116     -7210.8524     -7210.8524      313.09203      313.09203      177957.53      177957.53      125.67654      125.67654    
Loop time of 228.597 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.499 hours/ns, 4.375 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    | 227.2      | 227.2      | 227.2      |   0.0 | 99.39
Neigh   | 0.33194    | 0.33194    | 0.33194    |   0.0 |  0.15
Comm    | 0.12317    | 0.12317    | 0.12317    |   0.0 |  0.05
Output  | 0.0002417  | 0.0002417  | 0.0002417  |   0.0 |  0.00
Modify  | 0.84445    | 0.84445    | 0.84445    |   0.0 |  0.37
Other   |            | 0.102      |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       196062 ave      196062 max      196062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 196062
Ave neighs/atom = 49.0155
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.927980141868, Press = 0.319415526611813
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -7049.0116     -7049.0116     -7210.8524     -7210.8524      313.09203      313.09203      177957.53      177957.53      125.67654      125.67654    
     59000  -7049.6626     -7049.6626     -7211.2104     -7211.2104      312.52524      312.52524      177944.09      177944.09      152.38896      152.38896    
Loop time of 229.273 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.687 hours/ns, 4.362 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    | 227.87     | 227.87     | 227.87     |   0.0 | 99.39
Neigh   | 0.33177    | 0.33177    | 0.33177    |   0.0 |  0.14
Comm    | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.05
Output  | 0.00024004 | 0.00024004 | 0.00024004 |   0.0 |  0.00
Modify  | 0.8446     | 0.8446     | 0.8446     |   0.0 |  0.37
Other   |            | 0.103      |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195232 ave      195232 max      195232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195232
Ave neighs/atom = 48.808
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.916551716411, Press = -0.0954992588794569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -7049.6626     -7049.6626     -7211.2104     -7211.2104      312.52524      312.52524      177944.09      177944.09      152.38896      152.38896    
     60000  -7054.9427     -7054.9427     -7214.6822     -7214.6822      309.02685      309.02685      178097.08      178097.08     -84.56668      -84.56668     
Loop time of 229.349 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.708 hours/ns, 4.360 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    | 227.96     | 227.96     | 227.96     |   0.0 | 99.40
Neigh   | 0.33291    | 0.33291    | 0.33291    |   0.0 |  0.15
Comm    | 0.12311    | 0.12311    | 0.12311    |   0.0 |  0.05
Output  | 0.00024116 | 0.00024116 | 0.00024116 |   0.0 |  0.00
Modify  | 0.82956    | 0.82956    | 0.82956    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195550 ave      195550 max      195550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195550
Ave neighs/atom = 48.8875
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.925746016473, Press = 0.00252486502492145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -7054.9427     -7054.9427     -7214.6822     -7214.6822      309.02685      309.02685      178097.08      178097.08     -84.56668      -84.56668     
     61000  -7043.3071     -7043.3071     -7212.2777     -7212.2777      326.88494      326.88494      178212.79      178212.79     -79.614191     -79.614191    
Loop time of 229.464 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.740 hours/ns, 4.358 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    | 228.06     | 228.06     | 228.06     |   0.0 | 99.39
Neigh   | 0.33457    | 0.33457    | 0.33457    |   0.0 |  0.15
Comm    | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.05
Output  | 0.00019321 | 0.00019321 | 0.00019321 |   0.0 |  0.00
Modify  | 0.83939    | 0.83939    | 0.83939    |   0.0 |  0.37
Other   |            | 0.103      |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195756 ave      195756 max      195756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195756
Ave neighs/atom = 48.939
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.939018173939, Press = 0.103724772713442
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.766 | 3.766 | 3.766 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -7043.3071     -7043.3071     -7212.2777     -7212.2777      326.88494      326.88494      178212.79      178212.79     -79.614191     -79.614191    
     62000  -7051.404      -7051.404      -7214.4608     -7214.4608      315.44427      315.44427      177990.38      177990.38      44.052781      44.052781    
Loop time of 229.418 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.727 hours/ns, 4.359 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    | 228.02     | 228.02     | 228.02     |   0.0 | 99.39
Neigh   | 0.33324    | 0.33324    | 0.33324    |   0.0 |  0.15
Comm    | 0.12364    | 0.12364    | 0.12364    |   0.0 |  0.05
Output  | 0.00019308 | 0.00019308 | 0.00019308 |   0.0 |  0.00
Modify  | 0.83998    | 0.83998    | 0.83998    |   0.0 |  0.37
Other   |            | 0.1024     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       195566 ave      195566 max      195566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 195566
Ave neighs/atom = 48.8915
Neighbor list builds = 9
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
178071.903751063

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0