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

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

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

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

kim_interactions Li

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

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


mass          1 ${mass_converted}
mass          1 6.941

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.2      | 174.2      | 174.2      |   0.0 | 99.50
Neigh   | 0.38832    | 0.38832    | 0.38832    |   0.0 |  0.22
Comm    | 0.08775    | 0.08775    | 0.08775    |   0.0 |  0.05
Output  | 0.00021096 | 0.00021096 | 0.00021096 |   0.0 |  0.00
Modify  | 0.3361     | 0.3361     | 0.3361     |   0.0 |  0.19
Other   |            | 0.05512    |            |       |  0.03

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

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

Performance: 0.497 ns/day, 48.332 hours/ns, 5.747 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.02     | 173.02     | 173.02     |   0.0 | 99.44
Neigh   | 0.49851    | 0.49851    | 0.49851    |   0.0 |  0.29
Comm    | 0.090287   | 0.090287   | 0.090287   |   0.0 |  0.05
Output  | 0.00025068 | 0.00025068 | 0.00025068 |   0.0 |  0.00
Modify  | 0.33449    | 0.33449    | 0.33449    |   0.0 |  0.19
Other   |            | 0.05467    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3271 ave        3271 max        3271 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121056 ave      121056 max      121056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.27     | 173.27     | 173.27     |   0.0 | 99.45
Neigh   | 0.47687    | 0.47687    | 0.47687    |   0.0 |  0.27
Comm    | 0.089535   | 0.089535   | 0.089535   |   0.0 |  0.05
Output  | 0.00020559 | 0.00020559 | 0.00020559 |   0.0 |  0.00
Modify  | 0.33487    | 0.33487    | 0.33487    |   0.0 |  0.19
Other   |            | 0.05478    |            |       |  0.03

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

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

Performance: 0.498 ns/day, 48.180 hours/ns, 5.765 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    | 172.47     | 172.47     | 172.47     |   0.0 | 99.44
Neigh   | 0.49664    | 0.49664    | 0.49664    |   0.0 |  0.29
Comm    | 0.090719   | 0.090719   | 0.090719   |   0.0 |  0.05
Output  | 0.00020615 | 0.00020615 | 0.00020615 |   0.0 |  0.00
Modify  | 0.3336     | 0.3336     | 0.3336     |   0.0 |  0.19
Other   |            | 0.0545     |            |       |  0.03

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

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

Performance: 0.498 ns/day, 48.224 hours/ns, 5.760 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    | 172.63     | 172.63     | 172.63     |   0.0 | 99.44
Neigh   | 0.49875    | 0.49875    | 0.49875    |   0.0 |  0.29
Comm    | 0.090457   | 0.090457   | 0.090457   |   0.0 |  0.05
Output  | 0.00016613 | 0.00016613 | 0.00016613 |   0.0 |  0.00
Modify  | 0.3355     | 0.3355     | 0.3355     |   0.0 |  0.19
Other   |            | 0.05463    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3281 ave        3281 max        3281 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120752 ave      120752 max      120752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120752
Ave neighs/atom = 60.376
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 = 297.335807789744, Press = -262.677807049604
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3135.3979     -3135.3979     -3213.5799     -3213.5799      302.57233      302.57233      44798.032      44798.032     -252.10062     -252.10062    
      6000  -3139.3909     -3139.3909     -3212.3522     -3212.3522      282.36773      282.36773      44551.729      44551.729      377.08223      377.08223    
Loop time of 173.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.226 hours/ns, 5.760 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    | 172.64     | 172.64     | 172.64     |   0.0 | 99.44
Neigh   | 0.47592    | 0.47592    | 0.47592    |   0.0 |  0.27
Comm    | 0.089702   | 0.089702   | 0.089702   |   0.0 |  0.05
Output  | 0.00016825 | 0.00016825 | 0.00016825 |   0.0 |  0.00
Modify  | 0.35384    | 0.35384    | 0.35384    |   0.0 |  0.20
Other   |            | 0.05463    |            |       |  0.03

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

Total # of neighbors = 121068
Ave neighs/atom = 60.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 = 292.915718561014, Press = -29.5263496391629
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3139.3909     -3139.3909     -3212.3522     -3212.3522      282.36773      282.36773      44551.729      44551.729      377.08223      377.08223    
      7000  -3134.5638     -3134.5638     -3210.4337     -3210.4337      293.62436      293.62436      44703.309      44703.309      125.98768      125.98768    
Loop time of 173.637 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.233 hours/ns, 5.759 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    | 172.66     | 172.66     | 172.66     |   0.0 | 99.44
Neigh   | 0.47491    | 0.47491    | 0.47491    |   0.0 |  0.27
Comm    | 0.089314   | 0.089314   | 0.089314   |   0.0 |  0.05
Output  | 0.00016737 | 0.00016737 | 0.00016737 |   0.0 |  0.00
Modify  | 0.35386    | 0.35386    | 0.35386    |   0.0 |  0.20
Other   |            | 0.05448    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3272 ave        3272 max        3272 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120934 ave      120934 max      120934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120934
Ave neighs/atom = 60.467
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 = 294.188643531786, Press = -1.9478664585522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3134.5638     -3134.5638     -3210.4337     -3210.4337      293.62436      293.62436      44703.309      44703.309      125.98768      125.98768    
      8000  -3139.4995     -3139.4995     -3213.7843     -3213.7843      287.49017      287.49017      44658.916      44658.916     -41.48493      -41.48493     
Loop time of 173.575 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.215 hours/ns, 5.761 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    | 172.6      | 172.6      | 172.6      |   0.0 | 99.44
Neigh   | 0.47553    | 0.47553    | 0.47553    |   0.0 |  0.27
Comm    | 0.089449   | 0.089449   | 0.089449   |   0.0 |  0.05
Output  | 0.00016589 | 0.00016589 | 0.00016589 |   0.0 |  0.00
Modify  | 0.35371    | 0.35371    | 0.35371    |   0.0 |  0.20
Other   |            | 0.05433    |            |       |  0.03

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

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

Performance: 0.498 ns/day, 48.236 hours/ns, 5.759 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    | 172.65     | 172.65     | 172.65     |   0.0 | 99.43
Neigh   | 0.4959     | 0.4959     | 0.4959     |   0.0 |  0.29
Comm    | 0.090073   | 0.090073   | 0.090073   |   0.0 |  0.05
Output  | 0.00020061 | 0.00020061 | 0.00020061 |   0.0 |  0.00
Modify  | 0.35413    | 0.35413    | 0.35413    |   0.0 |  0.20
Other   |            | 0.05481    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3284 ave        3284 max        3284 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121118 ave      121118 max      121118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.498 ns/day, 48.146 hours/ns, 5.769 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    | 172.33     | 172.33     | 172.33     |   0.0 | 99.43
Neigh   | 0.49629    | 0.49629    | 0.49629    |   0.0 |  0.29
Comm    | 0.09026    | 0.09026    | 0.09026    |   0.0 |  0.05
Output  | 0.00016609 | 0.00016609 | 0.00016609 |   0.0 |  0.00
Modify  | 0.3537     | 0.3537     | 0.3537     |   0.0 |  0.20
Other   |            | 0.05436    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3287 ave        3287 max        3287 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121112 ave      121112 max      121112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.477 ns/day, 50.317 hours/ns, 5.521 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 180.13     | 180.13     | 180.13     |   0.0 | 99.44
Neigh   | 0.48753    | 0.48753    | 0.48753    |   0.0 |  0.27
Comm    | 0.093401   | 0.093401   | 0.093401   |   0.0 |  0.05
Output  | 0.00016498 | 0.00016498 | 0.00016498 |   0.0 |  0.00
Modify  | 0.37551    | 0.37551    | 0.37551    |   0.0 |  0.21
Other   |            | 0.05596    |            |       |  0.03

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

Total # of neighbors = 121402
Ave neighs/atom = 60.701
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 = 294.207069076793, Press = -10.9725851517561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3135.474      -3135.474      -3211.3316     -3211.3316      293.5768       293.5768       44593.791      44593.791      318.62306      318.62306    
     12000  -3138.2095     -3138.2095     -3212.7361     -3212.7361      288.4257       288.4257       44432.069      44432.069      678.1886       678.1886     
Loop time of 180.258 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.072 hours/ns, 5.548 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    | 179.25     | 179.25     | 179.25     |   0.0 | 99.44
Neigh   | 0.48178    | 0.48178    | 0.48178    |   0.0 |  0.27
Comm    | 0.093355   | 0.093355   | 0.093355   |   0.0 |  0.05
Output  | 0.00016768 | 0.00016768 | 0.00016768 |   0.0 |  0.00
Modify  | 0.37277    | 0.37277    | 0.37277    |   0.0 |  0.21
Other   |            | 0.05623    |            |       |  0.03

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

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

Performance: 0.445 ns/day, 53.963 hours/ns, 5.148 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.17     | 193.17     | 193.17     |   0.0 | 99.43
Neigh   | 0.52865    | 0.52865    | 0.52865    |   0.0 |  0.27
Comm    | 0.099967   | 0.099967   | 0.099967   |   0.0 |  0.05
Output  | 0.00016722 | 0.00016722 | 0.00016722 |   0.0 |  0.00
Modify  | 0.41441    | 0.41441    | 0.41441    |   0.0 |  0.21
Other   |            | 0.05855    |            |       |  0.03

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.42     | 174.42     | 174.42     |   0.0 | 99.43
Neigh   | 0.5009     | 0.5009     | 0.5009     |   0.0 |  0.29
Comm    | 0.092718   | 0.092718   | 0.092718   |   0.0 |  0.05
Output  | 0.00051257 | 0.00051257 | 0.00051257 |   0.0 |  0.00
Modify  | 0.35911    | 0.35911    | 0.35911    |   0.0 |  0.20
Other   |            | 0.05394    |            |       |  0.03

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.87     | 173.87     | 173.87     |   0.0 | 99.44
Neigh   | 0.47804    | 0.47804    | 0.47804    |   0.0 |  0.27
Comm    | 0.091243   | 0.091243   | 0.091243   |   0.0 |  0.05
Output  | 0.00016518 | 0.00016518 | 0.00016518 |   0.0 |  0.00
Modify  | 0.3587     | 0.3587     | 0.3587     |   0.0 |  0.21
Other   |            | 0.05469    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3250 ave        3250 max        3250 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120938 ave      120938 max      120938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.22     | 174.22     | 174.22     |   0.0 | 99.44
Neigh   | 0.47966    | 0.47966    | 0.47966    |   0.0 |  0.27
Comm    | 0.091772   | 0.091772   | 0.091772   |   0.0 |  0.05
Output  | 0.00016896 | 0.00016896 | 0.00016896 |   0.0 |  0.00
Modify  | 0.35781    | 0.35781    | 0.35781    |   0.0 |  0.20
Other   |            | 0.05467    |            |       |  0.03

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.28     | 174.28     | 174.28     |   0.0 | 99.44
Neigh   | 0.47904    | 0.47904    | 0.47904    |   0.0 |  0.27
Comm    | 0.091969   | 0.091969   | 0.091969   |   0.0 |  0.05
Output  | 0.00016748 | 0.00016748 | 0.00016748 |   0.0 |  0.00
Modify  | 0.35832    | 0.35832    | 0.35832    |   0.0 |  0.20
Other   |            | 0.05458    |            |       |  0.03

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.28     | 174.28     | 174.28     |   0.0 | 99.44
Neigh   | 0.47954    | 0.47954    | 0.47954    |   0.0 |  0.27
Comm    | 0.090831   | 0.090831   | 0.090831   |   0.0 |  0.05
Output  | 0.00016746 | 0.00016746 | 0.00016746 |   0.0 |  0.00
Modify  | 0.35881    | 0.35881    | 0.35881    |   0.0 |  0.20
Other   |            | 0.0548     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3231 ave        3231 max        3231 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120670 ave      120670 max      120670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.475 ns/day, 50.489 hours/ns, 5.502 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 180.72     | 180.72     | 180.72     |   0.0 | 99.43
Neigh   | 0.51182    | 0.51182    | 0.51182    |   0.0 |  0.28
Comm    | 0.094877   | 0.094877   | 0.094877   |   0.0 |  0.05
Output  | 0.00017017 | 0.00017017 | 0.00017017 |   0.0 |  0.00
Modify  | 0.37673    | 0.37673    | 0.37673    |   0.0 |  0.21
Other   |            | 0.05614    |            |       |  0.03

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

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

Performance: 0.434 ns/day, 55.329 hours/ns, 5.020 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.05     | 198.05     | 198.05     |   0.0 | 99.43
Neigh   | 0.54559    | 0.54559    | 0.54559    |   0.0 |  0.27
Comm    | 0.10271    | 0.10271    | 0.10271    |   0.0 |  0.05
Output  | 0.00023147 | 0.00023147 | 0.00023147 |   0.0 |  0.00
Modify  | 0.42836    | 0.42836    | 0.42836    |   0.0 |  0.22
Other   |            | 0.05996    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3298 ave        3298 max        3298 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121184 ave      121184 max      121184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.461 ns/day, 52.089 hours/ns, 5.333 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.48     | 186.48     | 186.48     |   0.0 | 99.45
Neigh   | 0.49208    | 0.49208    | 0.49208    |   0.0 |  0.26
Comm    | 0.095961   | 0.095961   | 0.095961   |   0.0 |  0.05
Output  | 0.00022841 | 0.00022841 | 0.00022841 |   0.0 |  0.00
Modify  | 0.39057    | 0.39057    | 0.39057    |   0.0 |  0.21
Other   |            | 0.05718    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3305 ave        3305 max        3305 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121020 ave      121020 max      121020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.427 ns/day, 56.264 hours/ns, 4.937 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    | 201.43     | 201.43     | 201.43     |   0.0 | 99.45
Neigh   | 0.51754    | 0.51754    | 0.51754    |   0.0 |  0.26
Comm    | 0.10263    | 0.10263    | 0.10263    |   0.0 |  0.05
Output  | 0.00021124 | 0.00021124 | 0.00021124 |   0.0 |  0.00
Modify  | 0.43605    | 0.43605    | 0.43605    |   0.0 |  0.22
Other   |            | 0.06012    |            |       |  0.03

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

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

Performance: 0.426 ns/day, 56.312 hours/ns, 4.933 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    | 201.6      | 201.6      | 201.6      |   0.0 | 99.45
Neigh   | 0.5172     | 0.5172     | 0.5172     |   0.0 |  0.26
Comm    | 0.10345    | 0.10345    | 0.10345    |   0.0 |  0.05
Output  | 0.0002121  | 0.0002121  | 0.0002121  |   0.0 |  0.00
Modify  | 0.43892    | 0.43892    | 0.43892    |   0.0 |  0.22
Other   |            | 0.06041    |            |       |  0.03

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

Total # of neighbors = 121078
Ave neighs/atom = 60.539
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 = 292.936446515924, Press = -2.50993246187006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3140.8974     -3140.8974     -3214.5751     -3214.5751      285.14017      285.14017      44541.988      44541.988      233.19344      233.19344    
     24000  -3135.11       -3135.11       -3212.692      -3212.692       300.25056      300.25056      44522.859      44522.859      511.82529      511.82529    
Loop time of 204.992 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.84     | 203.84     | 203.84     |   0.0 | 99.44
Neigh   | 0.54647    | 0.54647    | 0.54647    |   0.0 |  0.27
Comm    | 0.10397    | 0.10397    | 0.10397    |   0.0 |  0.05
Output  | 0.00021423 | 0.00021423 | 0.00021423 |   0.0 |  0.00
Modify  | 0.44325    | 0.44325    | 0.44325    |   0.0 |  0.22
Other   |            | 0.06054    |            |       |  0.03

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.85     | 202.85     | 202.85     |   0.0 | 99.45
Neigh   | 0.52056    | 0.52056    | 0.52056    |   0.0 |  0.26
Comm    | 0.1035     | 0.1035     | 0.1035     |   0.0 |  0.05
Output  | 0.00016767 | 0.00016767 | 0.00016767 |   0.0 |  0.00
Modify  | 0.44249    | 0.44249    | 0.44249    |   0.0 |  0.22
Other   |            | 0.06038    |            |       |  0.03

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

Total # of neighbors = 120950
Ave neighs/atom = 60.475
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 = 292.90565242879, Press = 1.16555101005557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3137.5404     -3137.5404     -3213.151      -3213.151       292.62076      292.62076      44813.209      44813.209     -357.232       -357.232      
     26000  -3139.543      -3139.543      -3216.0726     -3216.0726      296.17714      296.17714      44712.774      44712.774     -200.40857     -200.40857    
Loop time of 203.253 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.459 hours/ns, 4.920 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.13     | 202.13     | 202.13     |   0.0 | 99.45
Neigh   | 0.52164    | 0.52164    | 0.52164    |   0.0 |  0.26
Comm    | 0.10346    | 0.10346    | 0.10346    |   0.0 |  0.05
Output  | 0.00016861 | 0.00016861 | 0.00016861 |   0.0 |  0.00
Modify  | 0.44184    | 0.44184    | 0.44184    |   0.0 |  0.22
Other   |            | 0.06074    |            |       |  0.03

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

Total # of neighbors = 120990
Ave neighs/atom = 60.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 = 292.883400943632, Press = -1.69855875182216
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3139.543      -3139.543      -3216.0726     -3216.0726      296.17714      296.17714      44712.774      44712.774     -200.40857     -200.40857    
     27000  -3134.4163     -3134.4163     -3212.8444     -3212.8444      303.52507      303.52507      44765.619      44765.619     -159.47174     -159.47174    
Loop time of 202.612 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.281 hours/ns, 4.936 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    | 201.49     | 201.49     | 201.49     |   0.0 | 99.45
Neigh   | 0.51454    | 0.51454    | 0.51454    |   0.0 |  0.25
Comm    | 0.10225    | 0.10225    | 0.10225    |   0.0 |  0.05
Output  | 0.00026842 | 0.00026842 | 0.00026842 |   0.0 |  0.00
Modify  | 0.4429     | 0.4429     | 0.4429     |   0.0 |  0.22
Other   |            | 0.06033    |            |       |  0.03

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

Total # of neighbors = 120980
Ave neighs/atom = 60.49
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 = 292.908770059775, Press = -2.04478636349349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3134.4163     -3134.4163     -3212.8444     -3212.8444      303.52507      303.52507      44765.619      44765.619     -159.47174     -159.47174    
     28000  -3138.1706     -3138.1706     -3215.1009     -3215.1009      297.7285       297.7285       44474.001      44474.001      500.93582      500.93582    
Loop time of 202.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.282 hours/ns, 4.935 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    | 201.47     | 201.47     | 201.47     |   0.0 | 99.44
Neigh   | 0.54323    | 0.54323    | 0.54323    |   0.0 |  0.27
Comm    | 0.10272    | 0.10272    | 0.10272    |   0.0 |  0.05
Output  | 0.00023035 | 0.00023035 | 0.00023035 |   0.0 |  0.00
Modify  | 0.43399    | 0.43399    | 0.43399    |   0.0 |  0.21
Other   |            | 0.05984    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3305 ave        3305 max        3305 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121170 ave      121170 max      121170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 121170
Ave neighs/atom = 60.585
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 = 292.969994077733, Press = -1.34279339518788
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3138.1706     -3138.1706     -3215.1009     -3215.1009      297.7285       297.7285       44474.001      44474.001      500.93582      500.93582    
     29000  -3138.9892     -3138.9892     -3215.1842     -3215.1842      294.88235      294.88235      44609.814      44609.814      114.00402      114.00402    
Loop time of 203.573 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.44     | 202.44     | 202.44     |   0.0 | 99.45
Neigh   | 0.52131    | 0.52131    | 0.52131    |   0.0 |  0.26
Comm    | 0.10323    | 0.10323    | 0.10323    |   0.0 |  0.05
Output  | 0.00025278 | 0.00025278 | 0.00025278 |   0.0 |  0.00
Modify  | 0.44245    | 0.44245    | 0.44245    |   0.0 |  0.22
Other   |            | 0.0608     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3359 ave        3359 max        3359 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121132 ave      121132 max      121132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.56     | 202.56     | 202.56     |   0.0 | 99.43
Neigh   | 0.54499    | 0.54499    | 0.54499    |   0.0 |  0.27
Comm    | 0.10425    | 0.10425    | 0.10425    |   0.0 |  0.05
Output  | 0.00016826 | 0.00016826 | 0.00016826 |   0.0 |  0.00
Modify  | 0.44303    | 0.44303    | 0.44303    |   0.0 |  0.22
Other   |            | 0.06047    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3298 ave        3298 max        3298 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120986 ave      120986 max      120986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.42     | 202.42     | 202.42     |   0.0 | 99.43
Neigh   | 0.54333    | 0.54333    | 0.54333    |   0.0 |  0.27
Comm    | 0.10401    | 0.10401    | 0.10401    |   0.0 |  0.05
Output  | 0.00020988 | 0.00020988 | 0.00020988 |   0.0 |  0.00
Modify  | 0.44624    | 0.44624    | 0.44624    |   0.0 |  0.22
Other   |            | 0.06116    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3266 ave        3266 max        3266 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120848 ave      120848 max      120848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.452 ns/day, 53.106 hours/ns, 5.231 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.12     | 190.12     | 190.12     |   0.0 | 99.44
Neigh   | 0.50442    | 0.50442    | 0.50442    |   0.0 |  0.26
Comm    | 0.097476   | 0.097476   | 0.097476   |   0.0 |  0.05
Output  | 0.0001667  | 0.0001667  | 0.0001667  |   0.0 |  0.00
Modify  | 0.40312    | 0.40312    | 0.40312    |   0.0 |  0.21
Other   |            | 0.05824    |            |       |  0.03

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

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

Performance: 0.494 ns/day, 48.589 hours/ns, 5.717 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.92     | 173.92     | 173.92     |   0.0 | 99.43
Neigh   | 0.50133    | 0.50133    | 0.50133    |   0.0 |  0.29
Comm    | 0.091739   | 0.091739   | 0.091739   |   0.0 |  0.05
Output  | 0.00016723 | 0.00016723 | 0.00016723 |   0.0 |  0.00
Modify  | 0.35707    | 0.35707    | 0.35707    |   0.0 |  0.20
Other   |            | 0.05453    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3357 ave        3357 max        3357 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       121028 ave      121028 max      121028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0