# 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 2.860342010855675*${_u_distance}
variable latticeconst_converted equal 2.860342010855675*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86034201085568
Lattice spacing in x,y,z = 2.8603420 2.8603420 2.8603420
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.603420 28.603420 28.603420)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.603420 28.603420 28.603420)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_FarkasCaro_2020_FeNiCrCoAl__MO_820335782779_000
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23402.0495396402 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_820335782779_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8531.3038   -8531.3038   -8601.8833   -8601.8833       273.15       273.15     23402.05     23402.05    3221.3631    3221.3631 
    1000   -8554.4401   -8554.4401   -8621.8521   -8621.8521    260.89123    260.89123    23824.034    23824.034   -2253.6517   -2253.6517 
Loop time of 31.8409 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.713 ns/day, 8.845 hours/ns, 31.406 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    | 31.082     | 31.082     | 31.082     |   0.0 | 97.62
Neigh   | 0.1914     | 0.1914     | 0.1914     |   0.0 |  0.60
Comm    | 0.13226    | 0.13226    | 0.13226    |   0.0 |  0.42
Output  | 0.00023454 | 0.00023454 | 0.00023454 |   0.0 |  0.00
Modify  | 0.36837    | 0.36837    | 0.36837    |   0.0 |  1.16
Other   |            | 0.06645    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5399.00 ave        5399 max        5399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      326656.0 ave      326656 max      326656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326656
Ave neighs/atom = 163.32800
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8554.4401   -8554.4401   -8621.8521   -8621.8521    260.89123    260.89123    23824.034    23824.034   -2253.6517   -2253.6517 
    2000   -8600.4609   -8600.4609    -8670.724    -8670.724    271.92525    271.92525    23629.586    23629.586    1902.1956    1902.1956 
Loop time of 31.8639 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.712 ns/day, 8.851 hours/ns, 31.383 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    | 31.081     | 31.081     | 31.081     |   0.0 | 97.54
Neigh   | 0.23594    | 0.23594    | 0.23594    |   0.0 |  0.74
Comm    | 0.12842    | 0.12842    | 0.12842    |   0.0 |  0.40
Output  | 0.00019389 | 0.00019389 | 0.00019389 |   0.0 |  0.00
Modify  | 0.35348    | 0.35348    | 0.35348    |   0.0 |  1.11
Other   |            | 0.06481    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328222.0 ave      328222 max      328222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328222
Ave neighs/atom = 164.11100
Neighbor list builds = 5
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8600.4609   -8600.4609    -8670.724    -8670.724    271.92525    271.92525    23629.586    23629.586    1902.1956    1902.1956 
    3000   -8595.8772   -8595.8772   -8666.7119   -8666.7119    274.13789    274.13789    23656.679    23656.679   -258.63867   -258.63867 
Loop time of 31.4023 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.751 ns/day, 8.723 hours/ns, 31.845 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    | 30.853     | 30.853     | 30.853     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12726    | 0.12726    | 0.12726    |   0.0 |  0.41
Output  | 0.00018658 | 0.00018658 | 0.00018658 |   0.0 |  0.00
Modify  | 0.35648    | 0.35648    | 0.35648    |   0.0 |  1.14
Other   |            | 0.06566    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328414.0 ave      328414 max      328414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328414
Ave neighs/atom = 164.20700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8595.8772   -8595.8772   -8666.7119   -8666.7119    274.13789    274.13789    23656.679    23656.679   -258.63867   -258.63867 
    4000   -8597.8328   -8597.8328   -8668.9377   -8668.9377    275.18327    275.18327    23666.565    23666.565   -1567.3055   -1567.3055 
Loop time of 30.8834 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.798 ns/day, 8.579 hours/ns, 32.380 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    | 30.345     | 30.345     | 30.345     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12421    | 0.12421    | 0.12421    |   0.0 |  0.40
Output  | 0.00018553 | 0.00018553 | 0.00018553 |   0.0 |  0.00
Modify  | 0.3495     | 0.3495     | 0.3495     |   0.0 |  1.13
Other   |            | 0.06488    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5381.00 ave        5381 max        5381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328142.0 ave      328142 max      328142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328142
Ave neighs/atom = 164.07100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8597.8328   -8597.8328   -8668.9377   -8668.9377    275.18327    275.18327    23666.565    23666.565   -1567.3055   -1567.3055 
    5000   -8603.5038   -8603.5038   -8670.3843   -8670.3843    258.83456    258.83456    23646.878    23646.878    475.95601    475.95601 
Loop time of 31.252 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.765 ns/day, 8.681 hours/ns, 31.998 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    | 30.712     | 30.712     | 30.712     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12419    | 0.12419    | 0.12419    |   0.0 |  0.40
Output  | 0.00015193 | 0.00015193 | 0.00015193 |   0.0 |  0.00
Modify  | 0.35008    | 0.35008    | 0.35008    |   0.0 |  1.12
Other   |            | 0.0652     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327346.0 ave      327346 max      327346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327346
Ave neighs/atom = 163.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 265.698902310159, Press = 87.7960739766593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8603.5038   -8603.5038   -8670.3843   -8670.3843    258.83456    258.83456    23646.878    23646.878    475.95601    475.95601 
    6000   -8597.6344   -8597.6344    -8668.977    -8668.977    276.10324    276.10324    23645.996    23645.996    879.56371    879.56371 
Loop time of 31.4778 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.744 hours/ns, 31.768 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    | 30.91      | 30.91      | 30.91      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12606    | 0.12606    | 0.12606    |   0.0 |  0.40
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.37496    | 0.37496    | 0.37496    |   0.0 |  1.19
Other   |            | 0.0662     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328118.0 ave      328118 max      328118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328118
Ave neighs/atom = 164.05900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.313209497716, Press = -39.9993394338631
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8597.6344   -8597.6344    -8668.977    -8668.977    276.10324    276.10324    23645.996    23645.996    879.56371    879.56371 
    7000   -8599.1249   -8599.1249   -8668.9624   -8668.9624    270.27858    270.27858    23642.109    23642.109    1183.0648    1183.0648 
Loop time of 32.128 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.689 ns/day, 8.924 hours/ns, 31.126 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    | 31.544     | 31.544     | 31.544     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12907    | 0.12907    | 0.12907    |   0.0 |  0.40
Output  | 0.00014925 | 0.00014925 | 0.00014925 |   0.0 |  0.00
Modify  | 0.38813    | 0.38813    | 0.38813    |   0.0 |  1.21
Other   |            | 0.06624    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5401.00 ave        5401 max        5401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327846.0 ave      327846 max      327846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327846
Ave neighs/atom = 163.92300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.414893265897, Press = -26.3187971911527
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8599.1249   -8599.1249   -8668.9624   -8668.9624    270.27858    270.27858    23642.109    23642.109    1183.0648    1183.0648 
    8000   -8601.8931   -8601.8931    -8669.533    -8669.533    261.77342    261.77342    23626.522    23626.522    2269.1833    2269.1833 
Loop time of 32.0731 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.694 ns/day, 8.909 hours/ns, 31.179 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    | 31.497     | 31.497     | 31.497     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12808    | 0.12808    | 0.12808    |   0.0 |  0.40
Output  | 0.00015197 | 0.00015197 | 0.00015197 |   0.0 |  0.00
Modify  | 0.38172    | 0.38172    | 0.38172    |   0.0 |  1.19
Other   |            | 0.06612    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327936.0 ave      327936 max      327936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327936
Ave neighs/atom = 163.96800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.620277455327, Press = -39.4530183875089
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8601.8931   -8601.8931    -8669.533    -8669.533    261.77342    261.77342    23626.522    23626.522    2269.1833    2269.1833 
    9000   -8601.2088   -8601.2088   -8671.3037   -8671.3037    271.27477    271.27477      23645.7      23645.7   -1547.9545   -1547.9545 
Loop time of 31.9463 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.705 ns/day, 8.874 hours/ns, 31.303 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    | 31.362     | 31.362     | 31.362     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1278     | 0.1278     | 0.1278     |   0.0 |  0.40
Output  | 0.00015292 | 0.00015292 | 0.00015292 |   0.0 |  0.00
Modify  | 0.3898     | 0.3898     | 0.3898     |   0.0 |  1.22
Other   |            | 0.06614    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328072.0 ave      328072 max      328072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328072
Ave neighs/atom = 164.03600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.620553282536, Press = -0.927827418359584
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8601.2088   -8601.2088   -8671.3037   -8671.3037    271.27477    271.27477      23645.7      23645.7   -1547.9545   -1547.9545 
   10000   -8599.5125   -8599.5125   -8670.7975   -8670.7975    275.88046    275.88046    23631.426    23631.426    937.88875    937.88875 
Loop time of 32.1323 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.689 ns/day, 8.926 hours/ns, 31.121 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    | 31.547     | 31.547     | 31.547     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12814    | 0.12814    | 0.12814    |   0.0 |  0.40
Output  | 0.00015313 | 0.00015313 | 0.00015313 |   0.0 |  0.00
Modify  | 0.39002    | 0.39002    | 0.39002    |   0.0 |  1.21
Other   |            | 0.06662    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327818.0 ave      327818 max      327818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327818
Ave neighs/atom = 163.90900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.219550336536, Press = 2.15804145512253
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8599.5125   -8599.5125   -8670.7975   -8670.7975    275.88046    275.88046    23631.426    23631.426    937.88875    937.88875 
   11000   -8600.9754   -8600.9754   -8668.6911   -8668.6911    262.06662    262.06662    23638.937    23638.937      1068.36      1068.36 
Loop time of 31.539 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.739 ns/day, 8.761 hours/ns, 31.707 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    | 30.968     | 30.968     | 30.968     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12644    | 0.12644    | 0.12644    |   0.0 |  0.40
Output  | 0.00023678 | 0.00023678 | 0.00023678 |   0.0 |  0.00
Modify  | 0.37769    | 0.37769    | 0.37769    |   0.0 |  1.20
Other   |            | 0.06638    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5391.00 ave        5391 max        5391 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327906.0 ave      327906 max      327906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327906
Ave neighs/atom = 163.95300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.322430020312, Press = -10.7558444712772
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8600.9754   -8600.9754   -8668.6911   -8668.6911    262.06662    262.06662    23638.937    23638.937      1068.36      1068.36 
   12000   -8597.5791   -8597.5791   -8667.5453   -8667.5453    270.77642    270.77642    23670.982    23670.982    -1577.727    -1577.727 
Loop time of 31.9051 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.708 ns/day, 8.863 hours/ns, 31.343 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    | 31.329     | 31.329     | 31.329     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12782    | 0.12782    | 0.12782    |   0.0 |  0.40
Output  | 0.00015235 | 0.00015235 | 0.00015235 |   0.0 |  0.00
Modify  | 0.38178    | 0.38178    | 0.38178    |   0.0 |  1.20
Other   |            | 0.06671    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5392.00 ave        5392 max        5392 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327946.0 ave      327946 max      327946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327946
Ave neighs/atom = 163.97300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.190067996088, Press = -10.4176420732375
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8597.5791   -8597.5791   -8667.5453   -8667.5453    270.77642    270.77642    23670.982    23670.982    -1577.727    -1577.727 
   13000   -8600.7744   -8600.7744   -8669.4002   -8669.4002    265.58917    265.58917    23676.896    23676.896   -2682.1115   -2682.1115 
Loop time of 32.2841 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.676 ns/day, 8.968 hours/ns, 30.975 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    | 31.692     | 31.692     | 31.692     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13072    | 0.13072    | 0.13072    |   0.0 |  0.40
Output  | 0.00015545 | 0.00015545 | 0.00015545 |   0.0 |  0.00
Modify  | 0.39422    | 0.39422    | 0.39422    |   0.0 |  1.22
Other   |            | 0.06666    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327676.0 ave      327676 max      327676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327676
Ave neighs/atom = 163.83800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.124686296504, Press = -3.09487194422945
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8600.7744   -8600.7744   -8669.4002   -8669.4002    265.58917    265.58917    23676.896    23676.896   -2682.1115   -2682.1115 
   14000   -8597.0713   -8597.0713    -8669.256    -8669.256    279.36213    279.36213    23655.405    23655.405   -55.977505   -55.977505 
Loop time of 31.2525 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.765 ns/day, 8.681 hours/ns, 31.997 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    | 30.689     | 30.689     | 30.689     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12439    | 0.12439    | 0.12439    |   0.0 |  0.40
Output  | 0.00019458 | 0.00019458 | 0.00019458 |   0.0 |  0.00
Modify  | 0.37285    | 0.37285    | 0.37285    |   0.0 |  1.19
Other   |            | 0.06607    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5384.00 ave        5384 max        5384 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327446.0 ave      327446 max      327446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327446
Ave neighs/atom = 163.72300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.987390265827, Press = 1.92234761668917
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8597.0713   -8597.0713    -8669.256    -8669.256    279.36213    279.36213    23655.405    23655.405   -55.977505   -55.977505 
   15000    -8601.869    -8601.869   -8670.6897   -8670.6897    266.34308    266.34308    23612.532    23612.532    2645.6951    2645.6951 
Loop time of 31.8975 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.709 ns/day, 8.860 hours/ns, 31.350 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    | 31.318     | 31.318     | 31.318     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1288     | 0.1288     | 0.1288     |   0.0 |  0.40
Output  | 0.0001529  | 0.0001529  | 0.0001529  |   0.0 |  0.00
Modify  | 0.38386    | 0.38386    | 0.38386    |   0.0 |  1.20
Other   |            | 0.06646    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5381.00 ave        5381 max        5381 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327578.0 ave      327578 max      327578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327578
Ave neighs/atom = 163.78900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.878767691225, Press = -2.73037435252049
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -8601.869    -8601.869   -8670.6897   -8670.6897    266.34308    266.34308    23612.532    23612.532    2645.6951    2645.6951 
   16000   -8599.3203   -8599.3203   -8669.9222   -8669.9222    273.23671    273.23671    23602.489    23602.489    4376.2232    4376.2232 
Loop time of 31.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.762 ns/day, 8.688 hours/ns, 31.973 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    | 30.706     | 30.706     | 30.706     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12607    | 0.12607    | 0.12607    |   0.0 |  0.40
Output  | 0.0001561  | 0.0001561  | 0.0001561  |   0.0 |  0.00
Modify  | 0.37696    | 0.37696    | 0.37696    |   0.0 |  1.21
Other   |            | 0.06669    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5379.00 ave        5379 max        5379 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328326.0 ave      328326 max      328326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328326
Ave neighs/atom = 164.16300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.942028056575, Press = -3.50166326076439
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8599.3203   -8599.3203   -8669.9222   -8669.9222    273.23671    273.23671    23602.489    23602.489    4376.2232    4376.2232 
   17000   -8592.7448   -8592.7448   -8665.5162   -8665.5162    281.63301    281.63301     23641.72     23641.72    1287.8489    1287.8489 
Loop time of 31.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.715 ns/day, 8.839 hours/ns, 31.425 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    | 31.246     | 31.246     | 31.246     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12792    | 0.12792    | 0.12792    |   0.0 |  0.40
Output  | 0.00016154 | 0.00016154 | 0.00016154 |   0.0 |  0.00
Modify  | 0.38181    | 0.38181    | 0.38181    |   0.0 |  1.20
Other   |            | 0.06613    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5399.00 ave        5399 max        5399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328318.0 ave      328318 max      328318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328318
Ave neighs/atom = 164.15900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.119271936507, Press = 0.00457571777196241
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8592.7448   -8592.7448   -8665.5162   -8665.5162    281.63301    281.63301     23641.72     23641.72    1287.8489    1287.8489 
   18000    -8599.236    -8599.236   -8668.0091   -8668.0091    266.15891    266.15891    23627.582    23627.582    2552.9003    2552.9003 
Loop time of 32.2373 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.680 ns/day, 8.955 hours/ns, 31.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    | 31.656     | 31.656     | 31.656     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12833    | 0.12833    | 0.12833    |   0.0 |  0.40
Output  | 0.00019424 | 0.00019424 | 0.00019424 |   0.0 |  0.00
Modify  | 0.38664    | 0.38664    | 0.38664    |   0.0 |  1.20
Other   |            | 0.06624    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327802.0 ave      327802 max      327802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327802
Ave neighs/atom = 163.90100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.410591796943, Press = 3.97679899896915
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    -8599.236    -8599.236   -8668.0091   -8668.0091    266.15891    266.15891    23627.582    23627.582    2552.9003    2552.9003 
   19000   -8597.3222   -8597.3222   -8668.5295   -8668.5295    275.57935    275.57935    23630.354    23630.354    1692.5309    1692.5309 
Loop time of 31.9637 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.703 ns/day, 8.879 hours/ns, 31.286 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    | 31.383     | 31.383     | 31.383     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12844    | 0.12844    | 0.12844    |   0.0 |  0.40
Output  | 0.00015614 | 0.00015614 | 0.00015614 |   0.0 |  0.00
Modify  | 0.3855     | 0.3855     | 0.3855     |   0.0 |  1.21
Other   |            | 0.0668     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328014.0 ave      328014 max      328014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328014
Ave neighs/atom = 164.00700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.478886572184, Press = -2.39647842462082
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8597.3222   -8597.3222   -8668.5295   -8668.5295    275.57935    275.57935    23630.354    23630.354    1692.5309    1692.5309 
   20000   -8601.5996   -8601.5996    -8670.103    -8670.103    265.11547    265.11547    23635.135    23635.135    1514.2073    1514.2073 
Loop time of 32.5202 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.657 ns/day, 9.033 hours/ns, 30.750 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    | 31.941     | 31.941     | 31.941     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12763    | 0.12763    | 0.12763    |   0.0 |  0.39
Output  | 0.00015218 | 0.00015218 | 0.00015218 |   0.0 |  0.00
Modify  | 0.38603    | 0.38603    | 0.38603    |   0.0 |  1.19
Other   |            | 0.06588    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328130.0 ave      328130 max      328130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328130
Ave neighs/atom = 164.06500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383891583068, Press = -3.74995075400473
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8601.5996   -8601.5996    -8670.103    -8670.103    265.11547    265.11547    23635.135    23635.135    1514.2073    1514.2073 
   21000   -8599.0421   -8599.0421   -8669.4067   -8669.4067    272.31813    272.31813    23654.638    23654.638   -1070.5739   -1070.5739 
Loop time of 31.0638 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.781 ns/day, 8.629 hours/ns, 32.192 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    | 30.5       | 30.5       | 30.5       |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12512    | 0.12512    | 0.12512    |   0.0 |  0.40
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.37282    | 0.37282    | 0.37282    |   0.0 |  1.20
Other   |            | 0.06598    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5379.00 ave        5379 max        5379 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327994.0 ave      327994 max      327994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327994
Ave neighs/atom = 163.99700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.461029664528, Press = -1.3867817110822
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8599.0421   -8599.0421   -8669.4067   -8669.4067    272.31813    272.31813    23654.638    23654.638   -1070.5739   -1070.5739 
   22000   -8596.7699   -8596.7699   -8668.2326   -8668.2326    276.56776    276.56776    23636.034    23636.034    1227.0915    1227.0915 
Loop time of 31.507 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.742 ns/day, 8.752 hours/ns, 31.739 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    | 30.937     | 30.937     | 30.937     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12599    | 0.12599    | 0.12599    |   0.0 |  0.40
Output  | 0.00015386 | 0.00015386 | 0.00015386 |   0.0 |  0.00
Modify  | 0.37837    | 0.37837    | 0.37837    |   0.0 |  1.20
Other   |            | 0.06584    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5389.00 ave        5389 max        5389 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327680.0 ave      327680 max      327680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327680
Ave neighs/atom = 163.84000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.60985892777, Press = 2.54235011445815
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8596.7699   -8596.7699   -8668.2326   -8668.2326    276.56776    276.56776    23636.034    23636.034    1227.0915    1227.0915 
   23000   -8598.3864   -8598.3864   -8670.2496   -8670.2496    278.11782    278.11782    23634.669    23634.669    983.87342    983.87342 
Loop time of 31.5288 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.758 hours/ns, 31.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    | 30.96      | 30.96      | 30.96      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12576    | 0.12576    | 0.12576    |   0.0 |  0.40
Output  | 0.00015341 | 0.00015341 | 0.00015341 |   0.0 |  0.00
Modify  | 0.37733    | 0.37733    | 0.37733    |   0.0 |  1.20
Other   |            | 0.066      |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5382.00 ave        5382 max        5382 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327804.0 ave      327804 max      327804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327804
Ave neighs/atom = 163.90200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.803831129572, Press = -1.76732950480258
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8598.3864   -8598.3864   -8670.2496   -8670.2496    278.11782    278.11782    23634.669    23634.669    983.87342    983.87342 
   24000   -8597.2076   -8597.2076   -8668.0778   -8668.0778    274.27498    274.27498    23696.665    23696.665   -3862.8791   -3862.8791 
Loop time of 32.4053 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.666 ns/day, 9.001 hours/ns, 30.859 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    | 31.812     | 31.812     | 31.812     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13047    | 0.13047    | 0.13047    |   0.0 |  0.40
Output  | 0.0001953  | 0.0001953  | 0.0001953  |   0.0 |  0.00
Modify  | 0.39569    | 0.39569    | 0.39569    |   0.0 |  1.22
Other   |            | 0.06712    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5389.00 ave        5389 max        5389 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328190.0 ave      328190 max      328190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328190
Ave neighs/atom = 164.09500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.853833202186, Press = -3.17214277904593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8597.2076   -8597.2076   -8668.0778   -8668.0778    274.27498    274.27498    23696.665    23696.665   -3862.8791   -3862.8791 
   25000   -8601.6726   -8601.6726   -8669.4126   -8669.4126    262.16074    262.16074    23629.246    23629.246    388.50238    388.50238 
Loop time of 32.2098 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.682 ns/day, 8.947 hours/ns, 31.046 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    | 31.619     | 31.619     | 31.619     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13117    | 0.13117    | 0.13117    |   0.0 |  0.41
Output  | 0.00015333 | 0.00015333 | 0.00015333 |   0.0 |  0.00
Modify  | 0.39305    | 0.39305    | 0.39305    |   0.0 |  1.22
Other   |            | 0.06634    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327008.0 ave      327008 max      327008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327008
Ave neighs/atom = 163.50400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.728931931731, Press = 2.89906111398284
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8601.6726   -8601.6726   -8669.4126   -8669.4126    262.16074    262.16074    23629.246    23629.246    388.50238    388.50238 
   26000   -8597.9655   -8597.9655   -8666.9921   -8666.9921    267.14001    267.14001    23630.201    23630.201    2335.1415    2335.1415 
Loop time of 32.225 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.681 ns/day, 8.951 hours/ns, 31.032 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    | 31.64      | 31.64      | 31.64      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13064    | 0.13064    | 0.13064    |   0.0 |  0.41
Output  | 0.00040259 | 0.00040259 | 0.00040259 |   0.0 |  0.00
Modify  | 0.38737    | 0.38737    | 0.38737    |   0.0 |  1.20
Other   |            | 0.06629    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5392.00 ave        5392 max        5392 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327874.0 ave      327874 max      327874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327874
Ave neighs/atom = 163.93700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.744634828101, Press = -0.372575966864528
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8597.9655   -8597.9655   -8666.9921   -8666.9921    267.14001    267.14001    23630.201    23630.201    2335.1415    2335.1415 
   27000   -8601.7795   -8601.7795   -8670.2613   -8670.2613    265.03175    265.03175    23619.219    23619.219    2711.3463    2711.3463 
Loop time of 31.5249 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.741 ns/day, 8.757 hours/ns, 31.721 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    | 30.956     | 30.956     | 30.956     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12627    | 0.12627    | 0.12627    |   0.0 |  0.40
Output  | 0.00015515 | 0.00015515 | 0.00015515 |   0.0 |  0.00
Modify  | 0.37754    | 0.37754    | 0.37754    |   0.0 |  1.20
Other   |            | 0.0653     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328070.0 ave      328070 max      328070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328070
Ave neighs/atom = 164.03500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.673069040561, Press = -0.147057837701054
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8601.7795   -8601.7795   -8670.2613   -8670.2613    265.03175    265.03175    23619.219    23619.219    2711.3463    2711.3463 
   28000    -8596.801    -8596.801   -8668.7558   -8668.7558    278.47241    278.47241    23622.466    23622.466    3063.8437    3063.8437 
Loop time of 31.9647 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.703 ns/day, 8.879 hours/ns, 31.284 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    | 31.382     | 31.382     | 31.382     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12837    | 0.12837    | 0.12837    |   0.0 |  0.40
Output  | 0.00015476 | 0.00015476 | 0.00015476 |   0.0 |  0.00
Modify  | 0.3872     | 0.3872     | 0.3872     |   0.0 |  1.21
Other   |            | 0.06679    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5399.00 ave        5399 max        5399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328254.0 ave      328254 max      328254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328254
Ave neighs/atom = 164.12700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.66496994104, Press = -5.01012924155787
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -8596.801    -8596.801   -8668.7558   -8668.7558    278.47241    278.47241    23622.466    23622.466    3063.8437    3063.8437 
   29000   -8600.3058   -8600.3058   -8667.5085   -8667.5085    260.08158    260.08158    23670.756    23670.756   -1052.2628   -1052.2628 
Loop time of 31.3404 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.757 ns/day, 8.706 hours/ns, 31.908 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    | 30.78      | 30.78      | 30.78      |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1258     | 0.1258     | 0.1258     |   0.0 |  0.40
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.36925    | 0.36925    | 0.36925    |   0.0 |  1.18
Other   |            | 0.06536    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328126.0 ave      328126 max      328126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328126
Ave neighs/atom = 164.06300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.683363343895, Press = -2.81487674506817
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8600.3058   -8600.3058   -8667.5085   -8667.5085    260.08158    260.08158    23670.756    23670.756   -1052.2628   -1052.2628 
   30000   -8595.4319   -8595.4319    -8668.553    -8668.553    282.98639    282.98639    23662.486    23662.486   -2340.6742   -2340.6742 
Loop time of 31.2308 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.766 ns/day, 8.675 hours/ns, 32.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    | 30.676     | 30.676     | 30.676     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12354    | 0.12354    | 0.12354    |   0.0 |  0.40
Output  | 0.00015535 | 0.00015535 | 0.00015535 |   0.0 |  0.00
Modify  | 0.36552    | 0.36552    | 0.36552    |   0.0 |  1.17
Other   |            | 0.06602    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5389.00 ave        5389 max        5389 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327472.0 ave      327472 max      327472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327472
Ave neighs/atom = 163.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.768271496387, Press = -0.355586624410153
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8595.4319   -8595.4319    -8668.553    -8668.553    282.98639    282.98639    23662.486    23662.486   -2340.6742   -2340.6742 
   31000   -8599.1719   -8599.1719   -8669.8554   -8669.8554    273.55246    273.55246    23642.717    23642.717    812.15891    812.15891 
Loop time of 31.2847 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.762 ns/day, 8.690 hours/ns, 31.964 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    | 30.721     | 30.721     | 30.721     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12513    | 0.12513    | 0.12513    |   0.0 |  0.40
Output  | 0.00021622 | 0.00021622 | 0.00021622 |   0.0 |  0.00
Modify  | 0.37257    | 0.37257    | 0.37257    |   0.0 |  1.19
Other   |            | 0.0656     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327604.0 ave      327604 max      327604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327604
Ave neighs/atom = 163.80200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.776539071233, Press = 0.0774180316733335
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8599.1719   -8599.1719   -8669.8554   -8669.8554    273.55246    273.55246    23642.717    23642.717    812.15891    812.15891 
   32000    -8603.448    -8603.448   -8670.5779   -8670.5779     259.7995     259.7995    23632.066    23632.066   -131.20813   -131.20813 
Loop time of 30.9766 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.789 ns/day, 8.605 hours/ns, 32.282 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    | 30.417     | 30.417     | 30.417     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12491    | 0.12491    | 0.12491    |   0.0 |  0.40
Output  | 0.00018274 | 0.00018274 | 0.00018274 |   0.0 |  0.00
Modify  | 0.36866    | 0.36866    | 0.36866    |   0.0 |  1.19
Other   |            | 0.06577    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327560.0 ave      327560 max      327560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327560
Ave neighs/atom = 163.78000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.790098334748, Press = -1.02897852995012
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -8603.448    -8603.448   -8670.5779   -8670.5779     259.7995     259.7995    23632.066    23632.066   -131.20813   -131.20813 
   33000    -8597.895    -8597.895   -8669.4829   -8669.4829    277.05285    277.05285     23644.58     23644.58    365.81232    365.81232 
Loop time of 31.1774 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.771 ns/day, 8.660 hours/ns, 32.075 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    | 30.618     | 30.618     | 30.618     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12452    | 0.12452    | 0.12452    |   0.0 |  0.40
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.36869    | 0.36869    | 0.36869    |   0.0 |  1.18
Other   |            | 0.06606    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5382.00 ave        5382 max        5382 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328018.0 ave      328018 max      328018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328018
Ave neighs/atom = 164.00900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.737380085041, Press = -0.49309828165244
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -8597.895    -8597.895   -8669.4829   -8669.4829    277.05285    277.05285     23644.58     23644.58    365.81232    365.81232 
   34000   -8598.7804   -8598.7804   -8669.8197   -8669.8197    274.92947    274.92947    23610.747    23610.747    3483.4336    3483.4336 
Loop time of 31.3145 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.759 ns/day, 8.698 hours/ns, 31.934 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    | 30.751     | 30.751     | 30.751     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12526    | 0.12526    | 0.12526    |   0.0 |  0.40
Output  | 0.00020132 | 0.00020132 | 0.00020132 |   0.0 |  0.00
Modify  | 0.37209    | 0.37209    | 0.37209    |   0.0 |  1.19
Other   |            | 0.06568    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5384.00 ave        5384 max        5384 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327630.0 ave      327630 max      327630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327630
Ave neighs/atom = 163.81500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.740411486948, Press = -0.0813744140397378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8598.7804   -8598.7804   -8669.8197   -8669.8197    274.92947    274.92947    23610.747    23610.747    3483.4336    3483.4336 
   35000   -8596.3168   -8596.3168   -8668.9711   -8668.9711    281.17996    281.17996    23649.746    23649.746   -237.67749   -237.67749 
Loop time of 31.5561 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.738 ns/day, 8.766 hours/ns, 31.690 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    | 30.984     | 30.984     | 30.984     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12634    | 0.12634    | 0.12634    |   0.0 |  0.40
Output  | 0.00019923 | 0.00019923 | 0.00019923 |   0.0 |  0.00
Modify  | 0.37968    | 0.37968    | 0.37968    |   0.0 |  1.20
Other   |            | 0.06628    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5402.00 ave        5402 max        5402 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328458.0 ave      328458 max      328458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328458
Ave neighs/atom = 164.22900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.782092952544, Press = -3.5289095117939
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8596.3168   -8596.3168   -8668.9711   -8668.9711    281.17996    281.17996    23649.746    23649.746   -237.67749   -237.67749 
   36000   -8599.1241   -8599.1241   -8669.5862   -8669.5862    272.69548    272.69548    23673.681    23673.681   -2498.2669   -2498.2669 
Loop time of 31.4675 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.746 ns/day, 8.741 hours/ns, 31.779 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    | 30.897     | 30.897     | 30.897     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12607    | 0.12607    | 0.12607    |   0.0 |  0.40
Output  | 0.00015964 | 0.00015964 | 0.00015964 |   0.0 |  0.00
Modify  | 0.37786    | 0.37786    | 0.37786    |   0.0 |  1.20
Other   |            | 0.06593    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5368.00 ave        5368 max        5368 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327630.0 ave      327630 max      327630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327630
Ave neighs/atom = 163.81500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.821997371371, Press = -0.0474776798488189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8599.1241   -8599.1241   -8669.5862   -8669.5862    272.69548    272.69548    23673.681    23673.681   -2498.2669   -2498.2669 
   37000   -8595.5673   -8595.5673    -8666.416    -8666.416    274.19172    274.19172    23658.521    23658.521   -1074.8725   -1074.8725 
Loop time of 31.258 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.764 ns/day, 8.683 hours/ns, 31.992 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    | 30.697     | 30.697     | 30.697     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12513    | 0.12513    | 0.12513    |   0.0 |  0.40
Output  | 0.00015215 | 0.00015215 | 0.00015215 |   0.0 |  0.00
Modify  | 0.37037    | 0.37037    | 0.37037    |   0.0 |  1.18
Other   |            | 0.0654     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327196.0 ave      327196 max      327196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327196
Ave neighs/atom = 163.59800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.880381205558, Press = 0.98320053429175
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8595.5673   -8595.5673    -8666.416    -8666.416    274.19172    274.19172    23658.521    23658.521   -1074.8725   -1074.8725 
   38000   -8600.3571   -8600.3571   -8670.7463   -8670.7463    272.41335    272.41335    23627.395    23627.395    2149.5096    2149.5096 
Loop time of 30.6614 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.818 ns/day, 8.517 hours/ns, 32.614 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    | 30.11      | 30.11      | 30.11      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.40
Output  | 0.00015185 | 0.00015185 | 0.00015185 |   0.0 |  0.00
Modify  | 0.36325    | 0.36325    | 0.36325    |   0.0 |  1.18
Other   |            | 0.06559    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327660.0 ave      327660 max      327660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327660
Ave neighs/atom = 163.83000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.899041551526, Press = -0.951470162231402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8600.3571   -8600.3571   -8670.7463   -8670.7463    272.41335    272.41335    23627.395    23627.395    2149.5096    2149.5096 
   39000   -8597.8031   -8597.8031    -8669.147    -8669.147    276.10825    276.10825    23661.032    23661.032   -983.04661   -983.04661 
Loop time of 31.2447 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.765 ns/day, 8.679 hours/ns, 32.005 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    | 30.677     | 30.677     | 30.677     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12657    | 0.12657    | 0.12657    |   0.0 |  0.41
Output  | 0.0001564  | 0.0001564  | 0.0001564  |   0.0 |  0.00
Modify  | 0.37493    | 0.37493    | 0.37493    |   0.0 |  1.20
Other   |            | 0.06618    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327934.0 ave      327934 max      327934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327934
Ave neighs/atom = 163.96700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.896129205019, Press = -2.52323721406356
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8597.8031   -8597.8031    -8669.147    -8669.147    276.10825    276.10825    23661.032    23661.032   -983.04661   -983.04661 
   40000   -8601.1536   -8601.1536   -8669.7338   -8669.7338     265.4127     265.4127    23661.765    23661.765   -2879.7845   -2879.7845 
Loop time of 31.8097 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.836 hours/ns, 31.437 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    | 31.229     | 31.229     | 31.229     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12906    | 0.12906    | 0.12906    |   0.0 |  0.41
Output  | 0.00019562 | 0.00019562 | 0.00019562 |   0.0 |  0.00
Modify  | 0.38465    | 0.38465    | 0.38465    |   0.0 |  1.21
Other   |            | 0.06682    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327430.0 ave      327430 max      327430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327430
Ave neighs/atom = 163.71500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.816177913337, Press = -1.15433284739328
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8601.1536   -8601.1536   -8669.7338   -8669.7338     265.4127     265.4127    23661.765    23661.765   -2879.7845   -2879.7845 
   41000   -8596.0286   -8596.0286   -8667.3176   -8667.3176    275.89583    275.89583    23668.072    23668.072   -808.08418   -808.08418 
Loop time of 31.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.755 ns/day, 8.711 hours/ns, 31.890 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    | 30.791     | 30.791     | 30.791     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12651    | 0.12651    | 0.12651    |   0.0 |  0.40
Output  | 0.00015359 | 0.00015359 | 0.00015359 |   0.0 |  0.00
Modify  | 0.37465    | 0.37465    | 0.37465    |   0.0 |  1.19
Other   |            | 0.06576    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327538.0 ave      327538 max      327538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327538
Ave neighs/atom = 163.76900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.818104058229, Press = 2.59168222039849
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8596.0286   -8596.0286   -8667.3176   -8667.3176    275.89583    275.89583    23668.072    23668.072   -808.08418   -808.08418 
   42000   -8600.3987   -8600.3987   -8669.9085   -8669.9085    269.01032    269.01032    23597.315    23597.315     4901.102     4901.102 
Loop time of 31.4672 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.746 ns/day, 8.741 hours/ns, 31.779 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    | 30.899     | 30.899     | 30.899     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12592    | 0.12592    | 0.12592    |   0.0 |  0.40
Output  | 0.00019991 | 0.00019991 | 0.00019991 |   0.0 |  0.00
Modify  | 0.37587    | 0.37587    | 0.37587    |   0.0 |  1.19
Other   |            | 0.06607    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5396.00 ave        5396 max        5396 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327504.0 ave      327504 max      327504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327504
Ave neighs/atom = 163.75200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.857299565535, Press = 0.955521780692319
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8600.3987   -8600.3987   -8669.9085   -8669.9085    269.01032    269.01032    23597.315    23597.315     4901.102     4901.102 
   43000   -8596.8778   -8596.8778    -8668.434    -8668.434    276.92968    276.92968    23630.925    23630.925    1706.6817    1706.6817 
Loop time of 31.8408 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.713 ns/day, 8.845 hours/ns, 31.406 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    | 31.262     | 31.262     | 31.262     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12826    | 0.12826    | 0.12826    |   0.0 |  0.40
Output  | 0.00015577 | 0.00015577 | 0.00015577 |   0.0 |  0.00
Modify  | 0.38385    | 0.38385    | 0.38385    |   0.0 |  1.21
Other   |            | 0.06624    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5377.00 ave        5377 max        5377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      328490.0 ave      328490 max      328490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 328490
Ave neighs/atom = 164.24500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.908720487383, Press = -2.26186531639682
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8596.8778   -8596.8778    -8668.434    -8668.434    276.92968    276.92968    23630.925    23630.925    1706.6817    1706.6817 
   44000   -8596.8628   -8596.8628   -8669.2854   -8669.2854    280.28311    280.28311    23682.334    23682.334   -3380.4277   -3380.4277 
Loop time of 31.8347 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.714 ns/day, 8.843 hours/ns, 31.412 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    | 31.263     | 31.263     | 31.263     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12693    | 0.12693    | 0.12693    |   0.0 |  0.40
Output  | 0.00020621 | 0.00020621 | 0.00020621 |   0.0 |  0.00
Modify  | 0.37873    | 0.37873    | 0.37873    |   0.0 |  1.19
Other   |            | 0.06554    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327912.0 ave      327912 max      327912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327912
Ave neighs/atom = 163.95600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.922418918009, Press = -0.212143114101334
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8596.8628   -8596.8628   -8669.2854   -8669.2854    280.28311    280.28311    23682.334    23682.334   -3380.4277   -3380.4277 
   45000    -8602.372    -8602.372   -8670.7396   -8670.7396    264.58951    264.58951    23647.276    23647.276   -726.42952   -726.42952 
Loop time of 31.3629 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.755 ns/day, 8.712 hours/ns, 31.885 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    | 30.797     | 30.797     | 30.797     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12658    | 0.12658    | 0.12658    |   0.0 |  0.40
Output  | 0.00019346 | 0.00019346 | 0.00019346 |   0.0 |  0.00
Modify  | 0.37364    | 0.37364    | 0.37364    |   0.0 |  1.19
Other   |            | 0.06554    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5389.00 ave        5389 max        5389 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327044.0 ave      327044 max      327044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327044
Ave neighs/atom = 163.52200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.895427261882, Press = 1.16490938052759
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -8602.372    -8602.372   -8670.7396   -8670.7396    264.58951    264.58951    23647.276    23647.276   -726.42952   -726.42952 
   46000   -8599.0579   -8599.0579   -8671.4249   -8671.4249    280.06756    280.06756    23650.774    23650.774   -763.89396   -763.89396 
Loop time of 31.6357 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.731 ns/day, 8.788 hours/ns, 31.610 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    | 31.062     | 31.062     | 31.062     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12707    | 0.12707    | 0.12707    |   0.0 |  0.40
Output  | 0.00015509 | 0.00015509 | 0.00015509 |   0.0 |  0.00
Modify  | 0.37942    | 0.37942    | 0.37942    |   0.0 |  1.20
Other   |            | 0.06663    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5378.00 ave        5378 max        5378 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327730.0 ave      327730 max      327730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327730
Ave neighs/atom = 163.86500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.863386060546, Press = 0.618132875303202
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8599.0579   -8599.0579   -8671.4249   -8671.4249    280.06756    280.06756    23650.774    23650.774   -763.89396   -763.89396 
   47000    -8596.838    -8596.838   -8667.8316   -8667.8316    274.75276    274.75276    23641.777    23641.777    1094.2103    1094.2103 
Loop time of 31.7775 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.719 ns/day, 8.827 hours/ns, 31.469 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    | 31.195     | 31.195     | 31.195     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12835    | 0.12835    | 0.12835    |   0.0 |  0.40
Output  | 0.00015513 | 0.00015513 | 0.00015513 |   0.0 |  0.00
Modify  | 0.38682    | 0.38682    | 0.38682    |   0.0 |  1.22
Other   |            | 0.06679    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5374.00 ave        5374 max        5374 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327840.0 ave      327840 max      327840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327840
Ave neighs/atom = 163.92000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.862835351952, Press = 1.14691200856837
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -8596.838    -8596.838   -8667.8316   -8667.8316    274.75276    274.75276    23641.777    23641.777    1094.2103    1094.2103 
   48000   -8598.6057   -8598.6057   -8670.2154   -8670.2154    277.13665    277.13665     23636.72     23636.72    1622.4223    1622.4223 
Loop time of 31.5554 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.738 ns/day, 8.765 hours/ns, 31.690 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    | 30.983     | 30.983     | 30.983     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12692    | 0.12692    | 0.12692    |   0.0 |  0.40
Output  | 0.00019336 | 0.00019336 | 0.00019336 |   0.0 |  0.00
Modify  | 0.3792     | 0.3792     | 0.3792     |   0.0 |  1.20
Other   |            | 0.06649    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5391.00 ave        5391 max        5391 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327922.0 ave      327922 max      327922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327922
Ave neighs/atom = 163.96100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.920837180147, Press = 0.17385178085096
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8598.6057   -8598.6057   -8670.2154   -8670.2154    277.13665    277.13665     23636.72     23636.72    1622.4223    1622.4223 
   49000    -8595.069    -8595.069   -8666.9251   -8666.9251    278.09034    278.09034     23633.28     23633.28    2642.9444    2642.9444 
Loop time of 31.6375 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.731 ns/day, 8.788 hours/ns, 31.608 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    | 31.066     | 31.066     | 31.066     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12736    | 0.12736    | 0.12736    |   0.0 |  0.40
Output  | 0.00015379 | 0.00015379 | 0.00015379 |   0.0 |  0.00
Modify  | 0.37893    | 0.37893    | 0.37893    |   0.0 |  1.20
Other   |            | 0.06554    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5388.00 ave        5388 max        5388 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327858.0 ave      327858 max      327858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327858
Ave neighs/atom = 163.92900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.947535309753, Press = -0.670103274375194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000    -8595.069    -8595.069   -8666.9251   -8666.9251    278.09034    278.09034     23633.28     23633.28    2642.9444    2642.9444 
   50000   -8599.0689   -8599.0689    -8669.225    -8669.225    271.51123    271.51123        23641        23641    747.36325    747.36325 
Loop time of 32.2188 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.682 ns/day, 8.950 hours/ns, 31.038 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    | 31.631     | 31.631     | 31.631     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12906    | 0.12906    | 0.12906    |   0.0 |  0.40
Output  | 0.00015144 | 0.00015144 | 0.00015144 |   0.0 |  0.00
Modify  | 0.39189    | 0.39189    | 0.39189    |   0.0 |  1.22
Other   |            | 0.06636    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5380.00 ave        5380 max        5380 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327926.0 ave      327926 max      327926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327926
Ave neighs/atom = 163.96300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.978331579548, Press = -1.62363630809953
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8599.0689   -8599.0689    -8669.225    -8669.225    271.51123    271.51123        23641        23641    747.36325    747.36325 
   51000   -8596.7115   -8596.7115   -8666.0898   -8666.0898    268.50128    268.50128     23663.07     23663.07   -1682.7694   -1682.7694 
Loop time of 31.5984 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.777 hours/ns, 31.647 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    | 31.028     | 31.028     | 31.028     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12738    | 0.12738    | 0.12738    |   0.0 |  0.40
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.37806    | 0.37806    | 0.37806    |   0.0 |  1.20
Other   |            | 0.06526    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5388.00 ave        5388 max        5388 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327630.0 ave      327630 max      327630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327630
Ave neighs/atom = 163.81500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.01396834499, Press = -0.882491872468843
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8596.7115   -8596.7115   -8666.0898   -8666.0898    268.50128    268.50128     23663.07     23663.07   -1682.7694   -1682.7694 
   52000   -8598.7953   -8598.7953   -8669.3242   -8669.3242    272.95435    272.95435    23659.822    23659.822   -1824.5022   -1824.5022 
Loop time of 31.6508 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.730 ns/day, 8.792 hours/ns, 31.595 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    | 31.075     | 31.075     | 31.075     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12756    | 0.12756    | 0.12756    |   0.0 |  0.40
Output  | 0.0002014  | 0.0002014  | 0.0002014  |   0.0 |  0.00
Modify  | 0.38223    | 0.38223    | 0.38223    |   0.0 |  1.21
Other   |            | 0.06625    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5375.00 ave        5375 max        5375 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327572.0 ave      327572 max      327572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327572
Ave neighs/atom = 163.78600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.015768965782, Press = 0.246153808577489
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8598.7953   -8598.7953   -8669.3242   -8669.3242    272.95435    272.95435    23659.822    23659.822   -1824.5022   -1824.5022 
   53000   -8596.8629   -8596.8629   -8668.8154   -8668.8154    278.46358    278.46358    23636.592    23636.592    1730.8317    1730.8317 
Loop time of 31.8713 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.853 hours/ns, 31.376 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    | 31.293     | 31.293     | 31.293     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12762    | 0.12762    | 0.12762    |   0.0 |  0.40
Output  | 0.0001928  | 0.0001928  | 0.0001928  |   0.0 |  0.00
Modify  | 0.38386    | 0.38386    | 0.38386    |   0.0 |  1.20
Other   |            | 0.06625    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5363.00 ave        5363 max        5363 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327638.0 ave      327638 max      327638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327638
Ave neighs/atom = 163.81900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.038649826013, Press = 0.51625861765182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8596.8629   -8596.8629   -8668.8154   -8668.8154    278.46358    278.46358    23636.592    23636.592    1730.8317    1730.8317 
   54000   -8598.5038   -8598.5038   -8668.5809   -8668.5809     271.2053     271.2053    23630.037    23630.037    1654.1638    1654.1638 
Loop time of 31.7037 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.725 ns/day, 8.807 hours/ns, 31.542 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    | 31.134     | 31.134     | 31.134     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12697    | 0.12697    | 0.12697    |   0.0 |  0.40
Output  | 0.00015278 | 0.00015278 | 0.00015278 |   0.0 |  0.00
Modify  | 0.37767    | 0.37767    | 0.37767    |   0.0 |  1.19
Other   |            | 0.06521    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5383.00 ave        5383 max        5383 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327908.0 ave      327908 max      327908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327908
Ave neighs/atom = 163.95400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.036557216281, Press = -1.33064400559228
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8598.5038   -8598.5038   -8668.5809   -8668.5809     271.2053     271.2053    23630.037    23630.037    1654.1638    1654.1638 
   55000   -8597.3552   -8597.3552   -8669.2046   -8669.2046    278.06455    278.06455    23674.641    23674.641   -2939.3195   -2939.3195 
Loop time of 31.6786 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.727 ns/day, 8.800 hours/ns, 31.567 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    | 31.106     | 31.106     | 31.106     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12805    | 0.12805    | 0.12805    |   0.0 |  0.40
Output  | 0.00015371 | 0.00015371 | 0.00015371 |   0.0 |  0.00
Modify  | 0.37941    | 0.37941    | 0.37941    |   0.0 |  1.20
Other   |            | 0.06541    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      327900.0 ave      327900 max      327900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 327900
Ave neighs/atom = 163.95000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
23647.1077963516

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0