# 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.002 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_2018_FeNiCrCoCu__MO_803527979660_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_803527979660_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 32.8191 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.116 hours/ns, 30.470 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    | 32.052     | 32.052     | 32.052     |   0.0 | 97.66
Neigh   | 0.1919     | 0.1919     | 0.1919     |   0.0 |  0.58
Comm    | 0.13608    | 0.13608    | 0.13608    |   0.0 |  0.41
Output  | 0.00020176 | 0.00020176 | 0.00020176 |   0.0 |  0.00
Modify  | 0.37286    | 0.37286    | 0.37286    |   0.0 |  1.14
Other   |            | 0.0657     |            |       |  0.20

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 32.0006 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.700 ns/day, 8.889 hours/ns, 31.249 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.2       | 31.2       | 31.2       |   0.0 | 97.50
Neigh   | 0.2482     | 0.2482     | 0.2482     |   0.0 |  0.78
Comm    | 0.12823    | 0.12823    | 0.12823    |   0.0 |  0.40
Output  | 0.00020201 | 0.00020201 | 0.00020201 |   0.0 |  0.00
Modify  | 0.35871    | 0.35871    | 0.35871    |   0.0 |  1.12
Other   |            | 0.06494    |            |       |  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.0014 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.787 ns/day, 8.611 hours/ns, 32.257 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.462     | 30.462     | 30.462     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12465    | 0.12465    | 0.12465    |   0.0 |  0.40
Output  | 0.00022734 | 0.00022734 | 0.00022734 |   0.0 |  0.00
Modify  | 0.34958    | 0.34958    | 0.34958    |   0.0 |  1.13
Other   |            | 0.06524    |            |       |  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 31.1681 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.772 ns/day, 8.658 hours/ns, 32.084 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.626     | 30.626     | 30.626     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12436    | 0.12436    | 0.12436    |   0.0 |  0.40
Output  | 0.0001907  | 0.0001907  | 0.0001907  |   0.0 |  0.00
Modify  | 0.3518     | 0.3518     | 0.3518     |   0.0 |  1.13
Other   |            | 0.06567    |            |       |  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.3213 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.759 ns/day, 8.700 hours/ns, 31.927 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.78      | 30.78      | 30.78      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1235     | 0.1235     | 0.1235     |   0.0 |  0.39
Output  | 0.00015537 | 0.00015537 | 0.00015537 |   0.0 |  0.00
Modify  | 0.35334    | 0.35334    | 0.35334    |   0.0 |  1.13
Other   |            | 0.06472    |            |       |  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.4741 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.743 hours/ns, 31.772 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.908     | 30.908     | 30.908     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12571    | 0.12571    | 0.12571    |   0.0 |  0.40
Output  | 0.00019316 | 0.00019316 | 0.00019316 |   0.0 |  0.00
Modify  | 0.37448    | 0.37448    | 0.37448    |   0.0 |  1.19
Other   |            | 0.06532    |            |       |  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 31.6861 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.727 ns/day, 8.802 hours/ns, 31.560 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.109     | 31.109     | 31.109     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12701    | 0.12701    | 0.12701    |   0.0 |  0.40
Output  | 0.00015767 | 0.00015767 | 0.00015767 |   0.0 |  0.00
Modify  | 0.38432    | 0.38432    | 0.38432    |   0.0 |  1.21
Other   |            | 0.06581    |            |       |  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 33.053 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.614 ns/day, 9.181 hours/ns, 30.254 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    | 32.446     | 32.446     | 32.446     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13261    | 0.13261    | 0.13261    |   0.0 |  0.40
Output  | 0.00015451 | 0.00015451 | 0.00015451 |   0.0 |  0.00
Modify  | 0.40701    | 0.40701    | 0.40701    |   0.0 |  1.23
Other   |            | 0.06734    |            |       |  0.20

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 32.1003 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.692 ns/day, 8.917 hours/ns, 31.152 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.525     | 31.525     | 31.525     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12743    | 0.12743    | 0.12743    |   0.0 |  0.40
Output  | 0.00015633 | 0.00015633 | 0.00015633 |   0.0 |  0.00
Modify  | 0.38305    | 0.38305    | 0.38305    |   0.0 |  1.19
Other   |            | 0.0652     |            |       |  0.20

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.2227 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.681 ns/day, 8.951 hours/ns, 31.034 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.633     | 31.633     | 31.633     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12983    | 0.12983    | 0.12983    |   0.0 |  0.40
Output  | 0.0001876  | 0.0001876  | 0.0001876  |   0.0 |  0.00
Modify  | 0.39272    | 0.39272    | 0.39272    |   0.0 |  1.22
Other   |            | 0.06688    |            |       |  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.603 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.779 hours/ns, 31.643 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.036     | 31.036     | 31.036     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12501    | 0.12501    | 0.12501    |   0.0 |  0.40
Output  | 0.00015618 | 0.00015618 | 0.00015618 |   0.0 |  0.00
Modify  | 0.37638    | 0.37638    | 0.37638    |   0.0 |  1.19
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:        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.6208 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.732 ns/day, 8.784 hours/ns, 31.625 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.053     | 31.053     | 31.053     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12557    | 0.12557    | 0.12557    |   0.0 |  0.40
Output  | 0.00020397 | 0.00020397 | 0.00020397 |   0.0 |  0.00
Modify  | 0.37668    | 0.37668    | 0.37668    |   0.0 |  1.19
Other   |            | 0.06563    |            |       |  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 31.7548 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.721 ns/day, 8.821 hours/ns, 31.491 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.177     | 31.177     | 31.177     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12759    | 0.12759    | 0.12759    |   0.0 |  0.40
Output  | 0.00019966 | 0.00019966 | 0.00019966 |   0.0 |  0.00
Modify  | 0.38427    | 0.38427    | 0.38427    |   0.0 |  1.21
Other   |            | 0.06579    |            |       |  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.8693 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.853 hours/ns, 31.378 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.298     | 31.298     | 31.298     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12611    | 0.12611    | 0.12611    |   0.0 |  0.40
Output  | 0.00015481 | 0.00015481 | 0.00015481 |   0.0 |  0.00
Modify  | 0.37982    | 0.37982    | 0.37982    |   0.0 |  1.19
Other   |            | 0.06508    |            |       |  0.20

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.8666 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.852 hours/ns, 31.381 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.288     | 31.288     | 31.288     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12793    | 0.12793    | 0.12793    |   0.0 |  0.40
Output  | 0.00019821 | 0.00019821 | 0.00019821 |   0.0 |  0.00
Modify  | 0.3846     | 0.3846     | 0.3846     |   0.0 |  1.21
Other   |            | 0.06581    |            |       |  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.659 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.729 ns/day, 8.794 hours/ns, 31.587 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.09      | 31.09      | 31.09      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12596    | 0.12596    | 0.12596    |   0.0 |  0.40
Output  | 0.00015774 | 0.00015774 | 0.00015774 |   0.0 |  0.00
Modify  | 0.37661    | 0.37661    | 0.37661    |   0.0 |  1.19
Other   |            | 0.06594    |            |       |  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.3751 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.754 ns/day, 8.715 hours/ns, 31.872 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.813     | 30.813     | 30.813     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1247     | 0.1247     | 0.1247     |   0.0 |  0.40
Output  | 0.00019998 | 0.00019998 | 0.00019998 |   0.0 |  0.00
Modify  | 0.37203    | 0.37203    | 0.37203    |   0.0 |  1.19
Other   |            | 0.06517    |            |       |  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 31.4459 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.748 ns/day, 8.735 hours/ns, 31.801 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.88      | 30.88      | 30.88      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12473    | 0.12473    | 0.12473    |   0.0 |  0.40
Output  | 0.00019936 | 0.00019936 | 0.00019936 |   0.0 |  0.00
Modify  | 0.37554    | 0.37554    | 0.37554    |   0.0 |  1.19
Other   |            | 0.06546    |            |       |  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.8138 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.837 hours/ns, 31.433 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.24      | 31.24      | 31.24      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12719    | 0.12719    | 0.12719    |   0.0 |  0.40
Output  | 0.00015385 | 0.00015385 | 0.00015385 |   0.0 |  0.00
Modify  | 0.38124    | 0.38124    | 0.38124    |   0.0 |  1.20
Other   |            | 0.06534    |            |       |  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 31.8152 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.838 hours/ns, 31.431 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.238     | 31.238     | 31.238     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1279     | 0.1279     | 0.1279     |   0.0 |  0.40
Output  | 0.00015805 | 0.00015805 | 0.00015805 |   0.0 |  0.00
Modify  | 0.38408    | 0.38408    | 0.38408    |   0.0 |  1.21
Other   |            | 0.06556    |            |       |  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:      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 32.0601 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.695 ns/day, 8.906 hours/ns, 31.191 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.483     | 31.483     | 31.483     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1278     | 0.1278     | 0.1278     |   0.0 |  0.40
Output  | 0.00015247 | 0.00015247 | 0.00015247 |   0.0 |  0.00
Modify  | 0.38392    | 0.38392    | 0.38392    |   0.0 |  1.20
Other   |            | 0.06559    |            |       |  0.20

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.3862 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.753 ns/day, 8.718 hours/ns, 31.861 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.825     | 30.825     | 30.825     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12533    | 0.12533    | 0.12533    |   0.0 |  0.40
Output  | 0.00015583 | 0.00015583 | 0.00015583 |   0.0 |  0.00
Modify  | 0.37094    | 0.37094    | 0.37094    |   0.0 |  1.18
Other   |            | 0.06522    |            |       |  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.3853 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.753 ns/day, 8.718 hours/ns, 31.862 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.822     | 30.822     | 30.822     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1252     | 0.1252     | 0.1252     |   0.0 |  0.40
Output  | 0.00023946 | 0.00023946 | 0.00023946 |   0.0 |  0.00
Modify  | 0.37203    | 0.37203    | 0.37203    |   0.0 |  1.19
Other   |            | 0.06547    |            |       |  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.0374 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.697 ns/day, 8.899 hours/ns, 31.214 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.459     | 31.459     | 31.459     |   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.00015676 | 0.00015676 | 0.00015676 |   0.0 |  0.00
Modify  | 0.38434    | 0.38434    | 0.38434    |   0.0 |  1.20
Other   |            | 0.06599    |            |       |  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.3351 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.982 hours/ns, 30.926 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.754     | 31.754     | 31.754     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12858    | 0.12858    | 0.12858    |   0.0 |  0.40
Output  | 0.00019203 | 0.00019203 | 0.00019203 |   0.0 |  0.00
Modify  | 0.38708    | 0.38708    | 0.38708    |   0.0 |  1.20
Other   |            | 0.06538    |            |       |  0.20

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 31.7672 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.720 ns/day, 8.824 hours/ns, 31.479 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.198     | 31.198     | 31.198     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12617    | 0.12617    | 0.12617    |   0.0 |  0.40
Output  | 0.00038593 | 0.00038593 | 0.00038593 |   0.0 |  0.00
Modify  | 0.37767    | 0.37767    | 0.37767    |   0.0 |  1.19
Other   |            | 0.06539    |            |       |  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.779 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.719 ns/day, 8.828 hours/ns, 31.467 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.204     | 31.204     | 31.204     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12721    | 0.12721    | 0.12721    |   0.0 |  0.40
Output  | 0.00015893 | 0.00015893 | 0.00015893 |   0.0 |  0.00
Modify  | 0.38201    | 0.38201    | 0.38201    |   0.0 |  1.20
Other   |            | 0.06537    |            |       |  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.7292 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.723 ns/day, 8.814 hours/ns, 31.517 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.163     | 31.163     | 31.163     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12518    | 0.12518    | 0.12518    |   0.0 |  0.39
Output  | 0.00015938 | 0.00015938 | 0.00015938 |   0.0 |  0.00
Modify  | 0.37532    | 0.37532    | 0.37532    |   0.0 |  1.18
Other   |            | 0.06511    |            |       |  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.8103 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.836 hours/ns, 31.436 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.239     | 31.239     | 31.239     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12659    | 0.12659    | 0.12659    |   0.0 |  0.40
Output  | 0.00019352 | 0.00019352 | 0.00019352 |   0.0 |  0.00
Modify  | 0.37966    | 0.37966    | 0.37966    |   0.0 |  1.19
Other   |            | 0.0649     |            |       |  0.20

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.4379 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.748 ns/day, 8.733 hours/ns, 31.809 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.87      | 30.87      | 30.87      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12598    | 0.12598    | 0.12598    |   0.0 |  0.40
Output  | 0.00019713 | 0.00019713 | 0.00019713 |   0.0 |  0.00
Modify  | 0.37589    | 0.37589    | 0.37589    |   0.0 |  1.20
Other   |            | 0.06558    |            |       |  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 32.1614 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.686 ns/day, 8.934 hours/ns, 31.093 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.582     | 31.582     | 31.582     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12714    | 0.12714    | 0.12714    |   0.0 |  0.40
Output  | 0.00015572 | 0.00015572 | 0.00015572 |   0.0 |  0.00
Modify  | 0.38662    | 0.38662    | 0.38662    |   0.0 |  1.20
Other   |            | 0.06575    |            |       |  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:      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 31.177 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.615     | 30.615     | 30.615     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12429    | 0.12429    | 0.12429    |   0.0 |  0.40
Output  | 0.00015609 | 0.00015609 | 0.00015609 |   0.0 |  0.00
Modify  | 0.3727     | 0.3727     | 0.3727     |   0.0 |  1.20
Other   |            | 0.06538    |            |       |  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.4459 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.748 ns/day, 8.735 hours/ns, 31.801 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.884     | 30.884     | 30.884     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12468    | 0.12468    | 0.12468    |   0.0 |  0.40
Output  | 0.00015513 | 0.00015513 | 0.00015513 |   0.0 |  0.00
Modify  | 0.37261    | 0.37261    | 0.37261    |   0.0 |  1.18
Other   |            | 0.06494    |            |       |  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 32.0589 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.695 ns/day, 8.905 hours/ns, 31.193 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.471     | 31.471     | 31.471     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12828    | 0.12828    | 0.12828    |   0.0 |  0.40
Output  | 0.00015614 | 0.00015614 | 0.00015614 |   0.0 |  0.00
Modify  | 0.39253    | 0.39253    | 0.39253    |   0.0 |  1.22
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:        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.6279 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.732 ns/day, 8.786 hours/ns, 31.618 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.047     | 31.047     | 31.047     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1266     | 0.1266     | 0.1266     |   0.0 |  0.40
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.38852    | 0.38852    | 0.38852    |   0.0 |  1.23
Other   |            | 0.06535    |            |       |  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.0241 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.785 ns/day, 8.618 hours/ns, 32.233 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.469     | 30.469     | 30.469     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12317    | 0.12317    | 0.12317    |   0.0 |  0.40
Output  | 0.00015946 | 0.00015946 | 0.00015946 |   0.0 |  0.00
Modify  | 0.36619    | 0.36619    | 0.36619    |   0.0 |  1.18
Other   |            | 0.0655     |            |       |  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.8156 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.838 hours/ns, 31.431 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.243     | 31.243     | 31.243     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12645    | 0.12645    | 0.12645    |   0.0 |  0.40
Output  | 0.00015705 | 0.00015705 | 0.00015705 |   0.0 |  0.00
Modify  | 0.3804     | 0.3804     | 0.3804     |   0.0 |  1.20
Other   |            | 0.06519    |            |       |  0.20

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 31.7009 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.725 ns/day, 8.806 hours/ns, 31.545 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.126     | 31.126     | 31.126     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12773    | 0.12773    | 0.12773    |   0.0 |  0.40
Output  | 0.00015655 | 0.00015655 | 0.00015655 |   0.0 |  0.00
Modify  | 0.38106    | 0.38106    | 0.38106    |   0.0 |  1.20
Other   |            | 0.06558    |            |       |  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 30.9264 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.794 ns/day, 8.591 hours/ns, 32.335 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.373     | 30.373     | 30.373     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12319    | 0.12319    | 0.12319    |   0.0 |  0.40
Output  | 0.00020215 | 0.00020215 | 0.00020215 |   0.0 |  0.00
Modify  | 0.3653     | 0.3653     | 0.3653     |   0.0 |  1.18
Other   |            | 0.06492    |            |       |  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.9938 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.701 ns/day, 8.887 hours/ns, 31.256 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.415     | 31.415     | 31.415     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12743    | 0.12743    | 0.12743    |   0.0 |  0.40
Output  | 0.00019289 | 0.00019289 | 0.00019289 |   0.0 |  0.00
Modify  | 0.3854     | 0.3854     | 0.3854     |   0.0 |  1.20
Other   |            | 0.06544    |            |       |  0.20

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.3718 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.754 ns/day, 8.714 hours/ns, 31.876 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.8       | 30.8       | 30.8       |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12629    | 0.12629    | 0.12629    |   0.0 |  0.40
Output  | 0.00015728 | 0.00015728 | 0.00015728 |   0.0 |  0.00
Modify  | 0.37915    | 0.37915    | 0.37915    |   0.0 |  1.21
Other   |            | 0.06575    |            |       |  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.4526 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.747 ns/day, 8.737 hours/ns, 31.794 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.886     | 30.886     | 30.886     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12527    | 0.12527    | 0.12527    |   0.0 |  0.40
Output  | 0.00015908 | 0.00015908 | 0.00015908 |   0.0 |  0.00
Modify  | 0.37543    | 0.37543    | 0.37543    |   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:        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.8759 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.854 hours/ns, 31.372 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.295     | 31.295     | 31.295     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12836    | 0.12836    | 0.12836    |   0.0 |  0.40
Output  | 0.00021319 | 0.00021319 | 0.00021319 |   0.0 |  0.00
Modify  | 0.38651    | 0.38651    | 0.38651    |   0.0 |  1.21
Other   |            | 0.06563    |            |       |  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.7334 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.723 ns/day, 8.815 hours/ns, 31.513 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.165     | 31.165     | 31.165     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12628    | 0.12628    | 0.12628    |   0.0 |  0.40
Output  | 0.00015798 | 0.00015798 | 0.00015798 |   0.0 |  0.00
Modify  | 0.37619    | 0.37619    | 0.37619    |   0.0 |  1.19
Other   |            | 0.06548    |            |       |  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.1277 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.776 ns/day, 8.647 hours/ns, 32.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    | 30.57      | 30.57      | 30.57      |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1249     | 0.1249     | 0.1249     |   0.0 |  0.40
Output  | 0.00015561 | 0.00015561 | 0.00015561 |   0.0 |  0.00
Modify  | 0.36813    | 0.36813    | 0.36813    |   0.0 |  1.18
Other   |            | 0.06481    |            |       |  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.7659 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.720 ns/day, 8.824 hours/ns, 31.480 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.19      | 31.19      | 31.19      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12649    | 0.12649    | 0.12649    |   0.0 |  0.40
Output  | 0.00019866 | 0.00019866 | 0.00019866 |   0.0 |  0.00
Modify  | 0.38362    | 0.38362    | 0.38362    |   0.0 |  1.21
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:        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.3361 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.757 ns/day, 8.704 hours/ns, 31.912 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.771     | 30.771     | 30.771     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1249     | 0.1249     | 0.1249     |   0.0 |  0.40
Output  | 0.00015734 | 0.00015734 | 0.00015734 |   0.0 |  0.00
Modify  | 0.3747     | 0.3747     | 0.3747     |   0.0 |  1.20
Other   |            | 0.06553    |            |       |  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.5407 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.739 ns/day, 8.761 hours/ns, 31.705 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.97      | 30.97      | 30.97      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12624    | 0.12624    | 0.12624    |   0.0 |  0.40
Output  | 0.00015613 | 0.00015613 | 0.00015613 |   0.0 |  0.00
Modify  | 0.37837    | 0.37837    | 0.37837    |   0.0 |  1.20
Other   |            | 0.0659     |            |       |  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.3281 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.758 ns/day, 8.702 hours/ns, 31.920 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.767     | 30.767     | 30.767     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12457    | 0.12457    | 0.12457    |   0.0 |  0.40
Output  | 0.00015545 | 0.00015545 | 0.00015545 |   0.0 |  0.00
Modify  | 0.371      | 0.371      | 0.371      |   0.0 |  1.18
Other   |            | 0.06502    |            |       |  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.2983 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.972 hours/ns, 30.961 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.704     | 31.704     | 31.704     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13103    | 0.13103    | 0.13103    |   0.0 |  0.41
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.39665    | 0.39665    | 0.39665    |   0.0 |  1.23
Other   |            | 0.06632    |            |       |  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.5348 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.760 hours/ns, 31.711 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.97      | 30.97      | 30.97      |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12574    | 0.12574    | 0.12574    |   0.0 |  0.40
Output  | 0.00015146 | 0.00015146 | 0.00015146 |   0.0 |  0.00
Modify  | 0.37413    | 0.37413    | 0.37413    |   0.0 |  1.19
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 30.7146 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.813 ns/day, 8.532 hours/ns, 32.558 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.162     | 30.162     | 30.162     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12246    | 0.12246    | 0.12246    |   0.0 |  0.40
Output  | 0.00015569 | 0.00015569 | 0.00015569 |   0.0 |  0.00
Modify  | 0.36444    | 0.36444    | 0.36444    |   0.0 |  1.19
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:        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.5741 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.736 ns/day, 8.771 hours/ns, 31.671 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.001     | 31.001     | 31.001     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12594    | 0.12594    | 0.12594    |   0.0 |  0.40
Output  | 0.00015625 | 0.00015625 | 0.00015625 |   0.0 |  0.00
Modify  | 0.38001    | 0.38001    | 0.38001    |   0.0 |  1.20
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:        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.3726 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.754 ns/day, 8.715 hours/ns, 31.875 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.807     | 30.807     | 30.807     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12498    | 0.12498    | 0.12498    |   0.0 |  0.40
Output  | 0.00015699 | 0.00015699 | 0.00015699 |   0.0 |  0.00
Modify  | 0.37437    | 0.37437    | 0.37437    |   0.0 |  1.19
Other   |            | 0.0663     |            |       |  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.832 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.714 ns/day, 8.842 hours/ns, 31.415 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.256     | 31.256     | 31.256     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12721    | 0.12721    | 0.12721    |   0.0 |  0.40
Output  | 0.00019833 | 0.00019833 | 0.00019833 |   0.0 |  0.00
Modify  | 0.38299    | 0.38299    | 0.38299    |   0.0 |  1.20
Other   |            | 0.0655     |            |       |  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