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

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

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

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

kim_interactions Li

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

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


mass          1 ${mass_converted}
mass          1 6.941

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -3224.0166     -3224.0166     -3294.5961     -3294.5961      273.15         273.15         41144.143      41144.143      1832.2746      1832.2746    
      1000  -3152.5889     -3152.5889     -3221.9841     -3221.9841      268.56659      268.56659      42786.829      42786.829     -225.27819     -225.27819    
Loop time of 122.733 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.704 ns/day, 34.093 hours/ns, 8.148 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.85     | 121.85     | 121.85     |   0.0 | 99.28
Neigh   | 0.40589    | 0.40589    | 0.40589    |   0.0 |  0.33
Comm    | 0.087222   | 0.087222   | 0.087222   |   0.0 |  0.07
Output  | 0.00021253 | 0.00021253 | 0.00021253 |   0.0 |  0.00
Modify  | 0.33909    | 0.33909    | 0.33909    |   0.0 |  0.28
Other   |            | 0.05494    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119126 ave      119126 max      119126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119126
Ave neighs/atom = 59.563
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -3152.5889     -3152.5889     -3221.9841     -3221.9841      268.56659      268.56659      42786.829      42786.829     -225.27819     -225.27819    
      2000  -3154.6156     -3154.6156     -3225.319      -3225.319       273.62913      273.62913      42728.302      42728.302     -172.15408     -172.15408    
Loop time of 123.209 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.225 hours/ns, 8.116 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.28     | 122.28     | 122.28     |   0.0 | 99.25
Neigh   | 0.45071    | 0.45071    | 0.45071    |   0.0 |  0.37
Comm    | 0.088247   | 0.088247   | 0.088247   |   0.0 |  0.07
Output  | 0.00020774 | 0.00020774 | 0.00020774 |   0.0 |  0.00
Modify  | 0.33557    | 0.33557    | 0.33557    |   0.0 |  0.27
Other   |            | 0.05422    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3150 ave        3150 max        3150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119098 ave      119098 max      119098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119098
Ave neighs/atom = 59.549
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3154.6156     -3154.6156     -3225.319      -3225.319       273.62913      273.62913      42728.302      42728.302     -172.15408     -172.15408    
      3000  -3152.108      -3152.108      -3223.5486     -3223.5486      276.48253      276.48253      42622.429      42622.429      237.18234      237.18234    
Loop time of 123.388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.274 hours/ns, 8.105 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    | 122.44     | 122.44     | 122.44     |   0.0 | 99.23
Neigh   | 0.47211    | 0.47211    | 0.47211    |   0.0 |  0.38
Comm    | 0.088008   | 0.088008   | 0.088008   |   0.0 |  0.07
Output  | 0.00024086 | 0.00024086 | 0.00024086 |   0.0 |  0.00
Modify  | 0.33524    | 0.33524    | 0.33524    |   0.0 |  0.27
Other   |            | 0.05438    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3150 ave        3150 max        3150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119160 ave      119160 max      119160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119160
Ave neighs/atom = 59.58
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -3152.108      -3152.108      -3223.5486     -3223.5486      276.48253      276.48253      42622.429      42622.429      237.18234      237.18234    
      4000  -3153.2408     -3153.2408     -3224.9196     -3224.9196      277.4046       277.4046       42735.998      42735.998     -81.721403     -81.721403    
Loop time of 123.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.293 hours/ns, 8.100 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    | 122.5      | 122.5      | 122.5      |   0.0 | 99.23
Neigh   | 0.4719     | 0.4719     | 0.4719     |   0.0 |  0.38
Comm    | 0.088064   | 0.088064   | 0.088064   |   0.0 |  0.07
Output  | 0.00021007 | 0.00021007 | 0.00021007 |   0.0 |  0.00
Modify  | 0.33617    | 0.33617    | 0.33617    |   0.0 |  0.27
Other   |            | 0.05439    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3142 ave        3142 max        3142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119100 ave      119100 max      119100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.702 ns/day, 34.202 hours/ns, 8.122 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    | 122.18     | 122.18     | 122.18     |   0.0 | 99.23
Neigh   | 0.47131    | 0.47131    | 0.47131    |   0.0 |  0.38
Comm    | 0.088135   | 0.088135   | 0.088135   |   0.0 |  0.07
Output  | 0.00016931 | 0.00016931 | 0.00016931 |   0.0 |  0.00
Modify  | 0.33718    | 0.33718    | 0.33718    |   0.0 |  0.27
Other   |            | 0.0542     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3112 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119016 ave      119016 max      119016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119016
Ave neighs/atom = 59.508
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.236609709462, Press = -437.144216823777
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3153.4433     -3153.4433     -3224.4032     -3224.4032      274.62205      274.62205      42832.743      42832.743     -460.35986     -460.35986    
      6000  -3150.8757     -3150.8757     -3221.8261     -3221.8261      274.58554      274.58554      42746.338      42746.338     -80.732448     -80.732448    
Loop time of 123.312 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.253 hours/ns, 8.110 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    | 122.34     | 122.34     | 122.34     |   0.0 | 99.21
Neigh   | 0.4716     | 0.4716     | 0.4716     |   0.0 |  0.38
Comm    | 0.088041   | 0.088041   | 0.088041   |   0.0 |  0.07
Output  | 0.00016895 | 0.00016895 | 0.00016895 |   0.0 |  0.00
Modify  | 0.3547     | 0.3547     | 0.3547     |   0.0 |  0.29
Other   |            | 0.05413    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3100 ave        3100 max        3100 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119124 ave      119124 max      119124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119124
Ave neighs/atom = 59.562
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.689052083132, Press = -49.655401066224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3150.8757     -3150.8757     -3221.8261     -3221.8261      274.58554      274.58554      42746.338      42746.338     -80.732448     -80.732448    
      7000  -3154.1976     -3154.1976     -3225.0907     -3225.0907      274.36353      274.36353      42570.853      42570.853      231.69771      231.69771    
Loop time of 123.32 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.255 hours/ns, 8.109 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    | 122.35     | 122.35     | 122.35     |   0.0 | 99.21
Neigh   | 0.47216    | 0.47216    | 0.47216    |   0.0 |  0.38
Comm    | 0.088133   | 0.088133   | 0.088133   |   0.0 |  0.07
Output  | 0.00016964 | 0.00016964 | 0.00016964 |   0.0 |  0.00
Modify  | 0.35567    | 0.35567    | 0.35567    |   0.0 |  0.29
Other   |            | 0.05406    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3151 ave        3151 max        3151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119092 ave      119092 max      119092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119092
Ave neighs/atom = 59.546
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.46982530818, Press = -6.32879828659526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3154.1976     -3154.1976     -3225.0907     -3225.0907      274.36353      274.36353      42570.853      42570.853      231.69771      231.69771    
      8000  -3152.6678     -3152.6678     -3222.4818     -3222.4818      270.1871       270.1871       42801.946      42801.946     -259.2914      -259.2914     
Loop time of 123.481 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.300 hours/ns, 8.098 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    | 122.51     | 122.51     | 122.51     |   0.0 | 99.21
Neigh   | 0.47225    | 0.47225    | 0.47225    |   0.0 |  0.38
Comm    | 0.088264   | 0.088264   | 0.088264   |   0.0 |  0.07
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.35569    | 0.35569    | 0.35569    |   0.0 |  0.29
Other   |            | 0.05394    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3167 ave        3167 max        3167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119002 ave      119002 max      119002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119002
Ave neighs/atom = 59.501
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.510442221336, Press = -1.01335742933929
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3152.6678     -3152.6678     -3222.4818     -3222.4818      270.1871       270.1871       42801.946      42801.946     -259.2914      -259.2914     
      9000  -3153.0286     -3153.0286     -3222.8822     -3222.8822      270.34081      270.34081      42831.321      42831.321     -291.89043     -291.89043    
Loop time of 122.951 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.153 hours/ns, 8.133 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.98     | 121.98     | 121.98     |   0.0 | 99.21
Neigh   | 0.47207    | 0.47207    | 0.47207    |   0.0 |  0.38
Comm    | 0.088324   | 0.088324   | 0.088324   |   0.0 |  0.07
Output  | 0.00020315 | 0.00020315 | 0.00020315 |   0.0 |  0.00
Modify  | 0.35539    | 0.35539    | 0.35539    |   0.0 |  0.29
Other   |            | 0.05387    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119072 ave      119072 max      119072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119072
Ave neighs/atom = 59.536
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.541540020144, Press = -11.3035963735238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3153.0286     -3153.0286     -3222.8822     -3222.8822      270.34081      270.34081      42831.321      42831.321     -291.89043     -291.89043    
     10000  -3151.0587     -3151.0587     -3222.2636     -3222.2636      275.57034      275.57034      42459.488      42459.488      794.50341      794.50341    
Loop time of 123.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.239 hours/ns, 8.113 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    | 122.29     | 122.29     | 122.29     |   0.0 | 99.21
Neigh   | 0.4715     | 0.4715     | 0.4715     |   0.0 |  0.38
Comm    | 0.087931   | 0.087931   | 0.087931   |   0.0 |  0.07
Output  | 0.00017001 | 0.00017001 | 0.00017001 |   0.0 |  0.00
Modify  | 0.35594    | 0.35594    | 0.35594    |   0.0 |  0.29
Other   |            | 0.05421    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3163 ave        3163 max        3163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119326 ave      119326 max      119326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119326
Ave neighs/atom = 59.663
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.485868067925, Press = -8.42295279476008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3151.0587     -3151.0587     -3222.2636     -3222.2636      275.57034      275.57034      42459.488      42459.488      794.50341      794.50341    
     11000  -3151.1979     -3151.1979     -3222.3761     -3222.3761      275.4669       275.4669       42776.929      42776.929     -167.94108     -167.94108    
Loop time of 123.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.313 hours/ns, 8.096 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    | 122.56     | 122.56     | 122.56     |   0.0 | 99.22
Neigh   | 0.47076    | 0.47076    | 0.47076    |   0.0 |  0.38
Comm    | 0.087871   | 0.087871   | 0.087871   |   0.0 |  0.07
Output  | 0.00017026 | 0.00017026 | 0.00017026 |   0.0 |  0.00
Modify  | 0.35486    | 0.35486    | 0.35486    |   0.0 |  0.29
Other   |            | 0.05409    |            |       |  0.04

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

Total # of neighbors = 119074
Ave neighs/atom = 59.537
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.730299729548, Press = 3.4921449539351
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3151.1979     -3151.1979     -3222.3761     -3222.3761      275.4669       275.4669       42776.929      42776.929     -167.94108     -167.94108    
     12000  -3154.5635     -3154.5635     -3225.4611     -3225.4611      274.38095      274.38095      42771.448      42771.448     -268.53113     -268.53113    
Loop time of 123.154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.209 hours/ns, 8.120 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    | 122.19     | 122.19     | 122.19     |   0.0 | 99.21
Neigh   | 0.47101    | 0.47101    | 0.47101    |   0.0 |  0.38
Comm    | 0.088289   | 0.088289   | 0.088289   |   0.0 |  0.07
Output  | 0.00017017 | 0.00017017 | 0.00017017 |   0.0 |  0.00
Modify  | 0.35475    | 0.35475    | 0.35475    |   0.0 |  0.29
Other   |            | 0.05425    |            |       |  0.04

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

Total # of neighbors = 119144
Ave neighs/atom = 59.572
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.098112701894, Press = -3.91373758090389
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -3154.5635     -3154.5635     -3225.4611     -3225.4611      274.38095      274.38095      42771.448      42771.448     -268.53113     -268.53113    
     13000  -3153.3697     -3153.3697     -3222.8045     -3222.8045      268.71995      268.71995      42638.686      42638.686      163.59536      163.59536    
Loop time of 123.157 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.210 hours/ns, 8.120 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    | 122.19     | 122.19     | 122.19     |   0.0 | 99.21
Neigh   | 0.47196    | 0.47196    | 0.47196    |   0.0 |  0.38
Comm    | 0.087994   | 0.087994   | 0.087994   |   0.0 |  0.07
Output  | 0.00016961 | 0.00016961 | 0.00016961 |   0.0 |  0.00
Modify  | 0.35526    | 0.35526    | 0.35526    |   0.0 |  0.29
Other   |            | 0.05414    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3181 ave        3181 max        3181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119158 ave      119158 max      119158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119158
Ave neighs/atom = 59.579
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.308404141565, Press = -7.1206792434056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -3153.3697     -3153.3697     -3222.8045     -3222.8045      268.71995      268.71995      42638.686      42638.686      163.59536      163.59536    
     14000  -3152.3443     -3152.3443     -3221.9376     -3221.9376      269.33308      269.33308      42635.493      42635.493      257.57315      257.57315    
Loop time of 123.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.264 hours/ns, 8.107 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    | 122.38     | 122.38     | 122.38     |   0.0 | 99.21
Neigh   | 0.47088    | 0.47088    | 0.47088    |   0.0 |  0.38
Comm    | 0.088246   | 0.088246   | 0.088246   |   0.0 |  0.07
Output  | 0.00016969 | 0.00016969 | 0.00016969 |   0.0 |  0.00
Modify  | 0.35531    | 0.35531    | 0.35531    |   0.0 |  0.29
Other   |            | 0.05415    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3159 ave        3159 max        3159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119186 ave      119186 max      119186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119186
Ave neighs/atom = 59.593
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.284152390468, Press = -2.25493062563716
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3152.3443     -3152.3443     -3221.9376     -3221.9376      269.33308      269.33308      42635.493      42635.493      257.57315      257.57315    
     15000  -3151.7392     -3151.7392     -3221.9888     -3221.9888      271.87328      271.87328      42733.33       42733.33      -18.627077     -18.627077    
Loop time of 123.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.246 hours/ns, 8.111 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    | 122.32     | 122.32     | 122.32     |   0.0 | 99.21
Neigh   | 0.4716     | 0.4716     | 0.4716     |   0.0 |  0.38
Comm    | 0.088448   | 0.088448   | 0.088448   |   0.0 |  0.07
Output  | 0.00016988 | 0.00016988 | 0.00016988 |   0.0 |  0.00
Modify  | 0.3558     | 0.3558     | 0.3558     |   0.0 |  0.29
Other   |            | 0.05426    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3180 ave        3180 max        3180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119118 ave      119118 max      119118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119118
Ave neighs/atom = 59.559
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.307191591586, Press = 1.34730008703729
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -3151.7392     -3151.7392     -3221.9888     -3221.9888      271.87328      271.87328      42733.33       42733.33      -18.627077     -18.627077    
     16000  -3154.6982     -3154.6982     -3221.8494     -3221.8494      259.88208      259.88208      42917.138      42917.138     -600.02156     -600.02156    
Loop time of 123.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.202 hours/ns, 8.122 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    | 122.14     | 122.14     | 122.14     |   0.0 | 99.19
Neigh   | 0.49298    | 0.49298    | 0.49298    |   0.0 |  0.40
Comm    | 0.088615   | 0.088615   | 0.088615   |   0.0 |  0.07
Output  | 0.00017022 | 0.00017022 | 0.00017022 |   0.0 |  0.00
Modify  | 0.35575    | 0.35575    | 0.35575    |   0.0 |  0.29
Other   |            | 0.05402    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3109 ave        3109 max        3109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118976 ave      118976 max      118976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118976
Ave neighs/atom = 59.488
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.387545811141, Press = -1.87012010179502
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3154.6982     -3154.6982     -3221.8494     -3221.8494      259.88208      259.88208      42917.138      42917.138     -600.02156     -600.02156    
     17000  -3148.7732     -3148.7732     -3218.7975     -3218.7975      271.00121      271.00121      42722.521      42722.521      162.13573      162.13573    
Loop time of 123.134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.204 hours/ns, 8.121 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    | 122.16     | 122.16     | 122.16     |   0.0 | 99.21
Neigh   | 0.47148    | 0.47148    | 0.47148    |   0.0 |  0.38
Comm    | 0.087934   | 0.087934   | 0.087934   |   0.0 |  0.07
Output  | 0.00016923 | 0.00016923 | 0.00016923 |   0.0 |  0.00
Modify  | 0.35529    | 0.35529    | 0.35529    |   0.0 |  0.29
Other   |            | 0.05409    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3131 ave        3131 max        3131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118988 ave      118988 max      118988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118988
Ave neighs/atom = 59.494
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.486235791521, Press = -5.74490668314715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3148.7732     -3148.7732     -3218.7975     -3218.7975      271.00121      271.00121      42722.521      42722.521      162.13573      162.13573    
     18000  -3152.0429     -3152.0429     -3223.223      -3223.223       275.47443      275.47443      42606.288      42606.288      318.77513      318.77513    
Loop time of 123.557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.321 hours/ns, 8.093 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    | 122.61     | 122.61     | 122.61     |   0.0 | 99.23
Neigh   | 0.4503     | 0.4503     | 0.4503     |   0.0 |  0.36
Comm    | 0.088116   | 0.088116   | 0.088116   |   0.0 |  0.07
Output  | 0.00016982 | 0.00016982 | 0.00016982 |   0.0 |  0.00
Modify  | 0.35604    | 0.35604    | 0.35604    |   0.0 |  0.29
Other   |            | 0.05393    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3170 ave        3170 max        3170 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119266 ave      119266 max      119266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119266
Ave neighs/atom = 59.633
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.491934992013, Press = -0.237401546326298
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3152.0429     -3152.0429     -3223.223      -3223.223       275.47443      275.47443      42606.288      42606.288      318.77513      318.77513    
     19000  -3153.0239     -3153.0239     -3223.7284     -3223.7284      273.63384      273.63384      42813.169      42813.169     -370.18917     -370.18917    
Loop time of 123.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.222 hours/ns, 8.117 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    | 122.23     | 122.23     | 122.23     |   0.0 | 99.21
Neigh   | 0.47191    | 0.47191    | 0.47191    |   0.0 |  0.38
Comm    | 0.088153   | 0.088153   | 0.088153   |   0.0 |  0.07
Output  | 0.00017131 | 0.00017131 | 0.00017131 |   0.0 |  0.00
Modify  | 0.356      | 0.356      | 0.356      |   0.0 |  0.29
Other   |            | 0.05417    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3159 ave        3159 max        3159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119062 ave      119062 max      119062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119062
Ave neighs/atom = 59.531
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.490865356826, Press = -2.01319492432613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -3153.0239     -3153.0239     -3223.7284     -3223.7284      273.63384      273.63384      42813.169      42813.169     -370.18917     -370.18917    
     20000  -3152.7708     -3152.7708     -3223.8753     -3223.8753      275.18147      275.18147      42720.71       42720.71      -100.0602      -100.0602     
Loop time of 123.313 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.254 hours/ns, 8.109 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.34     | 122.34     | 122.34     |   0.0 | 99.21
Neigh   | 0.47165    | 0.47165    | 0.47165    |   0.0 |  0.38
Comm    | 0.08832    | 0.08832    | 0.08832    |   0.0 |  0.07
Output  | 0.00017159 | 0.00017159 | 0.00017159 |   0.0 |  0.00
Modify  | 0.35598    | 0.35598    | 0.35598    |   0.0 |  0.29
Other   |            | 0.05427    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3160 ave        3160 max        3160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119076 ave      119076 max      119076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119076
Ave neighs/atom = 59.538
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.398750984281, Press = -2.37496955406358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3152.7708     -3152.7708     -3223.8753     -3223.8753      275.18147      275.18147      42720.71       42720.71      -100.0602      -100.0602     
     21000  -3151.8528     -3151.8528     -3223.2073     -3223.2073      276.1494       276.1494       42689.784      42689.784      35.800538      35.800538    
Loop time of 123.295 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.249 hours/ns, 8.111 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.35     | 122.35     | 122.35     |   0.0 | 99.23
Neigh   | 0.45002    | 0.45002    | 0.45002    |   0.0 |  0.36
Comm    | 0.088178   | 0.088178   | 0.088178   |   0.0 |  0.07
Output  | 0.00017075 | 0.00017075 | 0.00017075 |   0.0 |  0.00
Modify  | 0.35563    | 0.35563    | 0.35563    |   0.0 |  0.29
Other   |            | 0.05443    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3114 ave        3114 max        3114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119158 ave      119158 max      119158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119158
Ave neighs/atom = 59.579
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.507036923722, Press = -2.02723221347087
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -3151.8528     -3151.8528     -3223.2073     -3223.2073      276.1494       276.1494       42689.784      42689.784      35.800538      35.800538    
     22000  -3152.1415     -3152.1415     -3222.6281     -3222.6281      272.79036      272.79036      42734.525      42734.525     -38.3618       -38.3618      
Loop time of 123.473 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.298 hours/ns, 8.099 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.5      | 122.5      | 122.5      |   0.0 | 99.21
Neigh   | 0.47165    | 0.47165    | 0.47165    |   0.0 |  0.38
Comm    | 0.087766   | 0.087766   | 0.087766   |   0.0 |  0.07
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.35646    | 0.35646    | 0.35646    |   0.0 |  0.29
Other   |            | 0.05417    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3153 ave        3153 max        3153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119076 ave      119076 max      119076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119076
Ave neighs/atom = 59.538
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.539764698078, Press = -0.395110658072836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3152.1415     -3152.1415     -3222.6281     -3222.6281      272.79036      272.79036      42734.525      42734.525     -38.3618       -38.3618      
     23000  -3154.5265     -3154.5265     -3223.804      -3223.804       268.11084      268.11084      42724.632      42724.632     -81.447863     -81.447863    
Loop time of 123.342 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.262 hours/ns, 8.108 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.37     | 122.37     | 122.37     |   0.0 | 99.21
Neigh   | 0.47215    | 0.47215    | 0.47215    |   0.0 |  0.38
Comm    | 0.088314   | 0.088314   | 0.088314   |   0.0 |  0.07
Output  | 0.00017015 | 0.00017015 | 0.00017015 |   0.0 |  0.00
Modify  | 0.35583    | 0.35583    | 0.35583    |   0.0 |  0.29
Other   |            | 0.05369    |            |       |  0.04

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

Total # of neighbors = 119148
Ave neighs/atom = 59.574
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.614767290387, Press = -0.83965157974012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3154.5265     -3154.5265     -3223.804      -3223.804       268.11084      268.11084      42724.632      42724.632     -81.447863     -81.447863    
     24000  -3151.1755     -3151.1755     -3223.1855     -3223.1855      278.68614      278.68614      42888.379      42888.379     -497.38782     -497.38782    
Loop time of 117.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.735 ns/day, 32.634 hours/ns, 8.512 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.55     | 116.55     | 116.55     |   0.0 | 99.21
Neigh   | 0.44911    | 0.44911    | 0.44911    |   0.0 |  0.38
Comm    | 0.084297   | 0.084297   | 0.084297   |   0.0 |  0.07
Output  | 0.00016035 | 0.00016035 | 0.00016035 |   0.0 |  0.00
Modify  | 0.34148    | 0.34148    | 0.34148    |   0.0 |  0.29
Other   |            | 0.05314    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3137 ave        3137 max        3137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118940 ave      118940 max      118940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118940
Ave neighs/atom = 59.47
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.591123816937, Press = -3.60692295763766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -3151.1755     -3151.1755     -3223.1855     -3223.1855      278.68614      278.68614      42888.379      42888.379     -497.38782     -497.38782    
     25000  -3149.4716     -3149.4716     -3222.9189     -3222.9189      284.24873      284.24873      42572.856      42572.856      451.94096      451.94096    
Loop time of 118.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 32.994 hours/ns, 8.419 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.84     | 117.84     | 117.84     |   0.0 | 99.21
Neigh   | 0.45501    | 0.45501    | 0.45501    |   0.0 |  0.38
Comm    | 0.085932   | 0.085932   | 0.085932   |   0.0 |  0.07
Output  | 0.00018114 | 0.00018114 | 0.00018114 |   0.0 |  0.00
Modify  | 0.34551    | 0.34551    | 0.34551    |   0.0 |  0.29
Other   |            | 0.05295    |            |       |  0.04

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

Total # of neighbors = 119276
Ave neighs/atom = 59.638
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.570907592644, Press = -1.43007556078515
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3149.4716     -3149.4716     -3222.9189     -3222.9189      284.24873      284.24873      42572.856      42572.856      451.94096      451.94096    
     26000  -3154.3028     -3154.3028     -3223.0208     -3223.0208      265.94562      265.94562      42752.152      42752.152     -114.98004     -114.98004    
Loop time of 121.609 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.780 hours/ns, 8.223 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.63     | 120.63     | 120.63     |   0.0 | 99.19
Neigh   | 0.48896    | 0.48896    | 0.48896    |   0.0 |  0.40
Comm    | 0.087787   | 0.087787   | 0.087787   |   0.0 |  0.07
Output  | 0.00016226 | 0.00016226 | 0.00016226 |   0.0 |  0.00
Modify  | 0.35202    | 0.35202    | 0.35202    |   0.0 |  0.29
Other   |            | 0.05366    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3157 ave        3157 max        3157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119058 ave      119058 max      119058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119058
Ave neighs/atom = 59.529
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.589282365782, Press = -0.587685251196414
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3154.3028     -3154.3028     -3223.0208     -3223.0208      265.94562      265.94562      42752.152      42752.152     -114.98004     -114.98004    
     27000  -3155.1639     -3155.1639     -3224.916      -3224.916       269.94771      269.94771      42674.974      42674.974      17.755086      17.755086    
Loop time of 117.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.733 ns/day, 32.747 hours/ns, 8.482 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.98     | 116.98     | 116.98     |   0.0 | 99.23
Neigh   | 0.42947    | 0.42947    | 0.42947    |   0.0 |  0.36
Comm    | 0.085398   | 0.085398   | 0.085398   |   0.0 |  0.07
Output  | 0.00024916 | 0.00024916 | 0.00024916 |   0.0 |  0.00
Modify  | 0.34215    | 0.34215    | 0.34215    |   0.0 |  0.29
Other   |            | 0.05301    |            |       |  0.04

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

Total # of neighbors = 119036
Ave neighs/atom = 59.518
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.558592798767, Press = -1.86143159211014
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3155.1639     -3155.1639     -3224.916      -3224.916       269.94771      269.94771      42674.974      42674.974      17.755086      17.755086    
     28000  -3151.7718     -3151.7718     -3220.7706     -3220.7706      267.03245      267.03245      42590.641      42590.641      449.83084      449.83084    
Loop time of 120.944 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.595 hours/ns, 8.268 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.99     | 119.99     | 119.99     |   0.0 | 99.21
Neigh   | 0.46227    | 0.46227    | 0.46227    |   0.0 |  0.38
Comm    | 0.08719    | 0.08719    | 0.08719    |   0.0 |  0.07
Output  | 0.00015952 | 0.00015952 | 0.00015952 |   0.0 |  0.00
Modify  | 0.35043    | 0.35043    | 0.35043    |   0.0 |  0.29
Other   |            | 0.05407    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119170 ave      119170 max      119170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119170
Ave neighs/atom = 59.585
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.54726093114, Press = -1.36483973879453
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3151.7718     -3151.7718     -3220.7706     -3220.7706      267.03245      267.03245      42590.641      42590.641      449.83084      449.83084    
     29000  -3153.141      -3153.141      -3223.2674     -3223.2674      271.3967       271.3967       42667.473      42667.473      72.637721      72.637721    
Loop time of 118.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.853 hours/ns, 8.455 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.33     | 117.33     | 117.33     |   0.0 | 99.21
Neigh   | 0.45449    | 0.45449    | 0.45449    |   0.0 |  0.38
Comm    | 0.085711   | 0.085711   | 0.085711   |   0.0 |  0.07
Output  | 0.00016148 | 0.00016148 | 0.00016148 |   0.0 |  0.00
Modify  | 0.34268    | 0.34268    | 0.34268    |   0.0 |  0.29
Other   |            | 0.05299    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3197 ave        3197 max        3197 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119258 ave      119258 max      119258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119258
Ave neighs/atom = 59.629
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.505735865671, Press = 1.33774126652865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -3153.141      -3153.141      -3223.2674     -3223.2674      271.3967       271.3967       42667.473      42667.473      72.637721      72.637721    
     30000  -3153.6529     -3153.6529     -3224.4996     -3224.4996      274.18429      274.18429      42815.638      42815.638     -470.97552     -470.97552    
Loop time of 119.63 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.231 hours/ns, 8.359 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.71     | 118.71     | 118.71     |   0.0 | 99.23
Neigh   | 0.4367     | 0.4367     | 0.4367     |   0.0 |  0.37
Comm    | 0.086292   | 0.086292   | 0.086292   |   0.0 |  0.07
Output  | 0.00016025 | 0.00016025 | 0.00016025 |   0.0 |  0.00
Modify  | 0.34718    | 0.34718    | 0.34718    |   0.0 |  0.29
Other   |            | 0.05359    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3160 ave        3160 max        3160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119030 ave      119030 max      119030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119030
Ave neighs/atom = 59.515
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.534027053353, Press = -1.28423170048901
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -3153.6529     -3153.6529     -3224.4996     -3224.4996      274.18429      274.18429      42815.638      42815.638     -470.97552     -470.97552    
     31000  -3149.7541     -3149.7541     -3220.902      -3220.902       275.3499       275.3499       42758.101      42758.101     -115.02983     -115.02983    
Loop time of 117.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.737 ns/day, 32.558 hours/ns, 8.532 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.28     | 116.28     | 116.28     |   0.0 | 99.21
Neigh   | 0.44767    | 0.44767    | 0.44767    |   0.0 |  0.38
Comm    | 0.084967   | 0.084967   | 0.084967   |   0.0 |  0.07
Output  | 0.00016106 | 0.00016106 | 0.00016106 |   0.0 |  0.00
Modify  | 0.34086    | 0.34086    | 0.34086    |   0.0 |  0.29
Other   |            | 0.05309    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3109 ave        3109 max        3109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119068 ave      119068 max      119068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119068
Ave neighs/atom = 59.534
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.569543494148, Press = -1.67549302655714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -3149.7541     -3149.7541     -3220.902      -3220.902       275.3499       275.3499       42758.101      42758.101     -115.02983     -115.02983    
     32000  -3151.9774     -3151.9774     -3223.6131     -3223.6131      277.23759      277.23759      42664.965      42664.965      140.21675      140.21675    
Loop time of 117.374 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.736 ns/day, 32.604 hours/ns, 8.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.44     | 116.44     | 116.44     |   0.0 | 99.21
Neigh   | 0.44952    | 0.44952    | 0.44952    |   0.0 |  0.38
Comm    | 0.085645   | 0.085645   | 0.085645   |   0.0 |  0.07
Output  | 0.00015984 | 0.00015984 | 0.00015984 |   0.0 |  0.00
Modify  | 0.34133    | 0.34133    | 0.34133    |   0.0 |  0.29
Other   |            | 0.05313    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3164 ave        3164 max        3164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119106 ave      119106 max      119106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119106
Ave neighs/atom = 59.553
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.559469613654, Press = -1.27843804071867
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -3151.9774     -3151.9774     -3223.6131     -3223.6131      277.23759      277.23759      42664.965      42664.965      140.21675      140.21675    
     33000  -3157.2681     -3157.2681     -3225.2581     -3225.2581      263.12841      263.12841      42636.054      42636.054     -29.164919     -29.164919    
Loop time of 118.568 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.729 ns/day, 32.936 hours/ns, 8.434 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.65     | 117.65     | 117.65     |   0.0 | 99.23
Neigh   | 0.43436    | 0.43436    | 0.43436    |   0.0 |  0.37
Comm    | 0.085758   | 0.085758   | 0.085758   |   0.0 |  0.07
Output  | 0.00020695 | 0.00020695 | 0.00020695 |   0.0 |  0.00
Modify  | 0.34474    | 0.34474    | 0.34474    |   0.0 |  0.29
Other   |            | 0.05305    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119092 ave      119092 max      119092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119092
Ave neighs/atom = 59.546
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.486329173886, Press = -0.981824443085437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -3157.2681     -3157.2681     -3225.2581     -3225.2581      263.12841      263.12841      42636.054      42636.054     -29.164919     -29.164919    
     34000  -3152.4612     -3152.4612     -3222.8754     -3222.8754      272.51042      272.51042      42637.452      42637.452      195.4029       195.4029     
Loop time of 117.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.734 ns/day, 32.681 hours/ns, 8.500 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.74     | 116.74     | 116.74     |   0.0 | 99.23
Neigh   | 0.42954    | 0.42954    | 0.42954    |   0.0 |  0.37
Comm    | 0.08519    | 0.08519    | 0.08519    |   0.0 |  0.07
Output  | 0.00016171 | 0.00016171 | 0.00016171 |   0.0 |  0.00
Modify  | 0.34055    | 0.34055    | 0.34055    |   0.0 |  0.29
Other   |            | 0.05327    |            |       |  0.05

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

Total # of neighbors = 119188
Ave neighs/atom = 59.594
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.46285533533, Press = -0.250602798917864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -3152.4612     -3152.4612     -3222.8754     -3222.8754      272.51042      272.51042      42637.452      42637.452      195.4029       195.4029     
     35000  -3152.1273     -3152.1273     -3222.2415     -3222.2415      271.34955      271.34955      42894.657      42894.657     -542.25146     -542.25146    
Loop time of 117.863 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.733 ns/day, 32.740 hours/ns, 8.484 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.93     | 116.93     | 116.93     |   0.0 | 99.21
Neigh   | 0.45305    | 0.45305    | 0.45305    |   0.0 |  0.38
Comm    | 0.085588   | 0.085588   | 0.085588   |   0.0 |  0.07
Output  | 0.00017034 | 0.00017034 | 0.00017034 |   0.0 |  0.00
Modify  | 0.34087    | 0.34087    | 0.34087    |   0.0 |  0.29
Other   |            | 0.05264    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3091 ave        3091 max        3091 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118988 ave      118988 max      118988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118988
Ave neighs/atom = 59.494
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.434426901018, Press = 0.318575649363781
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -3152.1273     -3152.1273     -3222.2415     -3222.2415      271.34955      271.34955      42894.657      42894.657     -542.25146     -542.25146    
     36000  -3153.6861     -3153.6861     -3224.557      -3224.557       274.27771      274.27771      42805.823      42805.823     -338.06709     -338.06709    
Loop time of 119.235 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.121 hours/ns, 8.387 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.27     | 118.27     | 118.27     |   0.0 | 99.19
Neigh   | 0.47454    | 0.47454    | 0.47454    |   0.0 |  0.40
Comm    | 0.086379   | 0.086379   | 0.086379   |   0.0 |  0.07
Output  | 0.00016077 | 0.00016077 | 0.00016077 |   0.0 |  0.00
Modify  | 0.34592    | 0.34592    | 0.34592    |   0.0 |  0.29
Other   |            | 0.05337    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3181 ave        3181 max        3181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119020 ave      119020 max      119020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119020
Ave neighs/atom = 59.51
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.453439623751, Press = -1.54242440759279
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -3153.6861     -3153.6861     -3224.557      -3224.557       274.27771      274.27771      42805.823      42805.823     -338.06709     -338.06709    
     37000  -3154.6085     -3154.6085     -3224.506      -3224.506       270.51061      270.51061      42587.319      42587.319      260.01633      260.01633    
Loop time of 117.723 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.734 ns/day, 32.701 hours/ns, 8.495 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.82     | 116.82     | 116.82     |   0.0 | 99.23
Neigh   | 0.42688    | 0.42688    | 0.42688    |   0.0 |  0.36
Comm    | 0.085796   | 0.085796   | 0.085796   |   0.0 |  0.07
Output  | 0.00016194 | 0.00016194 | 0.00016194 |   0.0 |  0.00
Modify  | 0.34132    | 0.34132    | 0.34132    |   0.0 |  0.29
Other   |            | 0.05239    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3127 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119202 ave      119202 max      119202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119202
Ave neighs/atom = 59.601
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.371561724345, Press = -0.938573559318544
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -3154.6085     -3154.6085     -3224.506      -3224.506       270.51061      270.51061      42587.319      42587.319      260.01633      260.01633    
     38000  -3153.2976     -3153.2976     -3223.139      -3223.139       270.2933       270.2933       42606.114      42606.114      261.32397      261.32397    
Loop time of 117.965 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.732 ns/day, 32.768 hours/ns, 8.477 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.06     | 117.06     | 117.06     |   0.0 | 99.23
Neigh   | 0.42696    | 0.42696    | 0.42696    |   0.0 |  0.36
Comm    | 0.085206   | 0.085206   | 0.085206   |   0.0 |  0.07
Output  | 0.00049909 | 0.00049909 | 0.00049909 |   0.0 |  0.00
Modify  | 0.34262    | 0.34262    | 0.34262    |   0.0 |  0.29
Other   |            | 0.05281    |            |       |  0.04

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

Total # of neighbors = 119154
Ave neighs/atom = 59.577
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.331526836936, Press = -0.477947819106352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -3153.2976     -3153.2976     -3223.139      -3223.139       270.2933       270.2933       42606.114      42606.114      261.32397      261.32397    
     39000  -3154.3494     -3154.3494     -3224.8666     -3224.8666      272.90857      272.90857      42844.212      42844.212     -484.56845     -484.56845    
Loop time of 118.898 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.027 hours/ns, 8.411 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.98     | 117.98     | 117.98     |   0.0 | 99.23
Neigh   | 0.43409    | 0.43409    | 0.43409    |   0.0 |  0.37
Comm    | 0.0854     | 0.0854     | 0.0854     |   0.0 |  0.07
Output  | 0.00020796 | 0.00020796 | 0.00020796 |   0.0 |  0.00
Modify  | 0.34431    | 0.34431    | 0.34431    |   0.0 |  0.29
Other   |            | 0.05347    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3121 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119000 ave      119000 max      119000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119000
Ave neighs/atom = 59.5
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.283237762465, Press = -0.468289262477334
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3154.3494     -3154.3494     -3224.8666     -3224.8666      272.90857      272.90857      42844.212      42844.212     -484.56845     -484.56845    
     40000  -3148.3688     -3148.3688     -3221.4099     -3221.4099      282.67642      282.67642      42755.181      42755.181     -25.284003     -25.284003    
Loop time of 118.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.031 hours/ns, 8.410 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.97     | 117.97     | 117.97     |   0.0 | 99.21
Neigh   | 0.45493    | 0.45493    | 0.45493    |   0.0 |  0.38
Comm    | 0.085218   | 0.085218   | 0.085218   |   0.0 |  0.07
Output  | 0.00016066 | 0.00016066 | 0.00016066 |   0.0 |  0.00
Modify  | 0.34462    | 0.34462    | 0.34462    |   0.0 |  0.29
Other   |            | 0.05279    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3168 ave        3168 max        3168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118990 ave      118990 max      118990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118990
Ave neighs/atom = 59.495
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.311712458249, Press = -1.97167533428913
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -3148.3688     -3148.3688     -3221.4099     -3221.4099      282.67642      282.67642      42755.181      42755.181     -25.284003     -25.284003    
     41000  -3155.9835     -3155.9835     -3224.5949     -3224.5949      265.53319      265.53319      42467.688      42467.688      602.67751      602.67751    
Loop time of 120.782 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.550 hours/ns, 8.279 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.83     | 119.83     | 119.83     |   0.0 | 99.21
Neigh   | 0.46253    | 0.46253    | 0.46253    |   0.0 |  0.38
Comm    | 0.087722   | 0.087722   | 0.087722   |   0.0 |  0.07
Output  | 0.0001611  | 0.0001611  | 0.0001611  |   0.0 |  0.00
Modify  | 0.34811    | 0.34811    | 0.34811    |   0.0 |  0.29
Other   |            | 0.05344    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3118 ave        3118 max        3118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119274 ave      119274 max      119274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119274
Ave neighs/atom = 59.637
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.330151380351, Press = -1.11810551650655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -3155.9835     -3155.9835     -3224.5949     -3224.5949      265.53319      265.53319      42467.688      42467.688      602.67751      602.67751    
     42000  -3152.0815     -3152.0815     -3222.3007     -3222.3007      271.75539      271.75539      42712.741      42712.741      11.025812      11.025812    
Loop time of 121.312 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.698 hours/ns, 8.243 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.35     | 120.35     | 120.35     |   0.0 | 99.21
Neigh   | 0.466      | 0.466      | 0.466      |   0.0 |  0.38
Comm    | 0.087895   | 0.087895   | 0.087895   |   0.0 |  0.07
Output  | 0.00016008 | 0.00016008 | 0.00016008 |   0.0 |  0.00
Modify  | 0.35197    | 0.35197    | 0.35197    |   0.0 |  0.29
Other   |            | 0.05353    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3170 ave        3170 max        3170 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119262 ave      119262 max      119262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0