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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.637506820261479*${_u_distance}
variable latticeconst_converted equal 3.637506820261479*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.63750682026148
Lattice spacing in x,y,z = 3.6375068 3.6375068 3.6375068
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 (36.375068 36.375068 36.375068)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.375068 36.375068 36.375068)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Pd

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

kim interactions Pd
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_ZhouBarteltSills_2021_PdHHe__MO_865505436319_000
pair_coeff * * Pd
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 106.42

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 48129.5109598337 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_865505436319_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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.386 | 7.386 | 7.386 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    34756.737    34756.737    34584.528    34584.528       333.15       333.15    48129.511    48129.511    3821.7076    3821.7076 
    1000    34955.188    34955.188     34771.09     34771.09    356.15055    356.15055    49029.754    49029.754   -420.67522   -420.67522 
Loop time of 106.349 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.812 ns/day, 29.541 hours/ns, 9.403 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    | 105.34     | 105.34     | 105.34     |   0.0 | 99.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20408    | 0.20408    | 0.20408    |   0.0 |  0.19
Output  | 0.00025831 | 0.00025831 | 0.00025831 |   0.0 |  0.00
Modify  | 0.69938    | 0.69938    | 0.69938    |   0.0 |  0.66
Other   |            | 0.1025     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      992000.0 ave      992000 max      992000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 992000
Ave neighs/atom = 248.00000
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    34955.188    34955.188     34771.09     34771.09    356.15055    356.15055    49029.754    49029.754   -420.67522   -420.67522 
    2000    34938.512    34938.512    34765.899    34765.899    333.93091    333.93091    48935.677    48935.677    482.55222    482.55222 
Loop time of 106.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.809 ns/day, 29.651 hours/ns, 9.368 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    | 105.74     | 105.74     | 105.74     |   0.0 | 99.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20603    | 0.20603    | 0.20603    |   0.0 |  0.19
Output  | 0.00025731 | 0.00025731 | 0.00025731 |   0.0 |  0.00
Modify  | 0.69638    | 0.69638    | 0.69638    |   0.0 |  0.65
Other   |            | 0.1024     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8281.00 ave        8281 max        8281 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:      955716.0 ave      955716 max      955716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 955716
Ave neighs/atom = 238.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 = 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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    34938.512    34938.512    34765.899    34765.899    333.93091    333.93091    48935.677    48935.677    482.55222    482.55222 
    3000    34943.021    34943.021    34766.992    34766.992    340.53932    340.53932    49001.151    49001.151   -496.50119   -496.50119 
Loop time of 106.819 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.809 ns/day, 29.672 hours/ns, 9.362 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    | 105.8      | 105.8      | 105.8      |   0.0 | 99.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20693    | 0.20693    | 0.20693    |   0.0 |  0.19
Output  | 0.00021525 | 0.00021525 | 0.00021525 |   0.0 |  0.00
Modify  | 0.7065     | 0.7065     | 0.7065     |   0.0 |  0.66
Other   |            | 0.1028     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8261.00 ave        8261 max        8261 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:      958404.0 ave      958404 max      958404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958404
Ave neighs/atom = 239.60100
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000    34943.021    34943.021    34766.992    34766.992    340.53932    340.53932    49001.151    49001.151   -496.50119   -496.50119 
    4000    34936.354    34936.354    34765.084    34765.084    331.33321    331.33321    48978.529    48978.529   -515.46492   -515.46492 
Loop time of 106.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.463 hours/ns, 9.428 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    | 105.07     | 105.07     | 105.07     |   0.0 | 99.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20417    | 0.20417    | 0.20417    |   0.0 |  0.19
Output  | 0.00021278 | 0.00021278 | 0.00021278 |   0.0 |  0.00
Modify  | 0.69174    | 0.69174    | 0.69174    |   0.0 |  0.65
Other   |            | 0.1022     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8241.00 ave        8241 max        8241 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:      956880.0 ave      956880 max      956880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956880
Ave neighs/atom = 239.22000
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    34936.354    34936.354    34765.084    34765.084    331.33321    331.33321    48978.529    48978.529   -515.46492   -515.46492 
    5000     34945.03     34945.03    34773.955    34773.955    330.95773    330.95773     48971.71     48971.71     638.2888     638.2888 
Loop time of 106.481 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.811 ns/day, 29.578 hours/ns, 9.391 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    | 105.47     | 105.47     | 105.47     |   0.0 | 99.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20534    | 0.20534    | 0.20534    |   0.0 |  0.19
Output  | 0.0001767  | 0.0001767  | 0.0001767  |   0.0 |  0.00
Modify  | 0.70477    | 0.70477    | 0.70477    |   0.0 |  0.66
Other   |            | 0.1031     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8266.00 ave        8266 max        8266 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:      957522.0 ave      957522 max      957522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957522
Ave neighs/atom = 239.38050
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 = 338.27107060539, Press = 749.941514874424
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000     34945.03     34945.03    34773.955    34773.955    330.95773    330.95773     48971.71     48971.71     638.2888     638.2888 
    6000    34940.862    34940.862    34767.942    34767.942    334.52557    334.52557    48962.193    48962.193    410.29506    410.29506 
Loop time of 104.288 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.828 ns/day, 28.969 hours/ns, 9.589 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    | 103.28     | 103.28     | 103.28     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20235    | 0.20235    | 0.20235    |   0.0 |  0.19
Output  | 0.00017788 | 0.00017788 | 0.00017788 |   0.0 |  0.00
Modify  | 0.69979    | 0.69979    | 0.69979    |   0.0 |  0.67
Other   |            | 0.1029     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8287.00 ave        8287 max        8287 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:      957440.0 ave      957440 max      957440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957440
Ave neighs/atom = 239.36000
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 = 333.300306040491, Press = 11.8978016697443
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    34940.862    34940.862    34767.942    34767.942    334.52557    334.52557    48962.193    48962.193    410.29506    410.29506 
    7000    34942.472    34942.472     34769.48     34769.48    334.66402    334.66402    49016.254    49016.254   -827.88664   -827.88664 
Loop time of 105.954 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.432 hours/ns, 9.438 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    | 104.93     | 104.93     | 104.93     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20469    | 0.20469    | 0.20469    |   0.0 |  0.19
Output  | 0.00017877 | 0.00017877 | 0.00017877 |   0.0 |  0.00
Modify  | 0.72       | 0.72       | 0.72       |   0.0 |  0.68
Other   |            | 0.1027     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8269.00 ave        8269 max        8269 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:      957548.0 ave      957548 max      957548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957548
Ave neighs/atom = 239.38700
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 = 333.158087404717, Press = 36.4231597494091
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    34942.472    34942.472     34769.48     34769.48    334.66402    334.66402    49016.254    49016.254   -827.88664   -827.88664 
    8000    34939.654    34939.654    34769.839    34769.839    328.51753    328.51753    48935.574    48935.574     952.5803     952.5803 
Loop time of 106.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.810 ns/day, 29.624 hours/ns, 9.377 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    | 105.62     | 105.62     | 105.62     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20594    | 0.20594    | 0.20594    |   0.0 |  0.19
Output  | 0.0002258  | 0.0002258  | 0.0002258  |   0.0 |  0.00
Modify  | 0.72001    | 0.72001    | 0.72001    |   0.0 |  0.68
Other   |            | 0.1015     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8254.00 ave        8254 max        8254 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:      956292.0 ave      956292 max      956292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956292
Ave neighs/atom = 239.07300
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 = 333.033066486438, Press = 20.9962314483282
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    34939.654    34939.654    34769.839    34769.839    328.51753    328.51753    48935.574    48935.574     952.5803     952.5803 
    9000    34944.026    34944.026     34772.21     34772.21    332.38982    332.38982    49027.546    49027.546   -778.01708   -778.01708 
Loop time of 106.194 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.498 hours/ns, 9.417 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    | 105.16     | 105.16     | 105.16     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20621    | 0.20621    | 0.20621    |   0.0 |  0.19
Output  | 0.00022124 | 0.00022124 | 0.00022124 |   0.0 |  0.00
Modify  | 0.72266    | 0.72266    | 0.72266    |   0.0 |  0.68
Other   |            | 0.1017     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8290.00 ave        8290 max        8290 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:      958350.0 ave      958350 max      958350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958350
Ave neighs/atom = 239.58750
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 = 332.882297849328, Press = -0.0606742436022376
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    34944.026    34944.026     34772.21     34772.21    332.38982    332.38982    49027.546    49027.546   -778.01708   -778.01708 
   10000    34937.061    34937.061    34769.926    34769.926    323.33425    323.33425    49047.322    49047.322   -1633.4142   -1633.4142 
Loop time of 105.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.280 hours/ns, 9.487 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    | 104.39     | 104.39     | 104.39     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20411    | 0.20411    | 0.20411    |   0.0 |  0.19
Output  | 0.00017737 | 0.00017737 | 0.00017737 |   0.0 |  0.00
Modify  | 0.71563    | 0.71563    | 0.71563    |   0.0 |  0.68
Other   |            | 0.1017     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8273.00 ave        8273 max        8273 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:      955898.0 ave      955898 max      955898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 955898
Ave neighs/atom = 238.97450
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 = 332.592319052597, Press = 8.15400452262418
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    34937.061    34937.061    34769.926    34769.926    323.33425    323.33425    49047.322    49047.322   -1633.4142   -1633.4142 
   11000    34937.459    34937.459    34767.112    34767.112    329.54712    329.54712    48957.147    48957.147    106.50027    106.50027 
Loop time of 104.7 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.083 hours/ns, 9.551 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    | 103.69     | 103.69     | 103.69     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20306    | 0.20306    | 0.20306    |   0.0 |  0.19
Output  | 0.00017738 | 0.00017738 | 0.00017738 |   0.0 |  0.00
Modify  | 0.70662    | 0.70662    | 0.70662    |   0.0 |  0.67
Other   |            | 0.1015     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8276.00 ave        8276 max        8276 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:      956014.0 ave      956014 max      956014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956014
Ave neighs/atom = 239.00350
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 = 332.80039020075, Press = 15.931398513025
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    34937.459    34937.459    34767.112    34767.112    329.54712    329.54712    48957.147    48957.147    106.50027    106.50027 
   12000    34945.501    34945.501    34771.623    34771.623    336.37799    336.37799    48926.688    48926.688    1371.1896    1371.1896 
Loop time of 104.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.829 ns/day, 28.938 hours/ns, 9.599 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    | 103.18     | 103.18     | 103.18     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20028    | 0.20028    | 0.20028    |   0.0 |  0.19
Output  | 0.0001772  | 0.0001772  | 0.0001772  |   0.0 |  0.00
Modify  | 0.699      | 0.699      | 0.699      |   0.0 |  0.67
Other   |            | 0.1015     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8284.00 ave        8284 max        8284 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:      957636.0 ave      957636 max      957636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957636
Ave neighs/atom = 239.40900
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 = 332.82837204339, Press = 2.63550346741125
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    34945.501    34945.501    34771.623    34771.623    336.37799    336.37799    48926.688    48926.688    1371.1896    1371.1896 
   13000    34946.061    34946.061    34772.487    34772.487    335.79161    335.79161    49013.097    49013.097    -418.3629    -418.3629 
Loop time of 105.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.323 hours/ns, 9.473 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    | 104.54     | 104.54     | 104.54     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20432    | 0.20432    | 0.20432    |   0.0 |  0.19
Output  | 0.00017667 | 0.00017667 | 0.00017667 |   0.0 |  0.00
Modify  | 0.71681    | 0.71681    | 0.71681    |   0.0 |  0.68
Other   |            | 0.1019     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8316.00 ave        8316 max        8316 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:      958258.0 ave      958258 max      958258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958258
Ave neighs/atom = 239.56450
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 = 332.884110013149, Press = 0.0813934141121738
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    34946.061    34946.061    34772.487    34772.487    335.79161    335.79161    49013.097    49013.097    -418.3629    -418.3629 
   14000    34941.471    34941.471    34769.859    34769.859    331.99446    331.99446    48998.554    48998.554   -494.24155   -494.24155 
Loop time of 104.882 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.134 hours/ns, 9.535 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    | 103.87     | 103.87     | 103.87     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20291    | 0.20291    | 0.20291    |   0.0 |  0.19
Output  | 0.0001773  | 0.0001773  | 0.0001773  |   0.0 |  0.00
Modify  | 0.70584    | 0.70584    | 0.70584    |   0.0 |  0.67
Other   |            | 0.1025     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8279.00 ave        8279 max        8279 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:      956710.0 ave      956710 max      956710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956710
Ave neighs/atom = 239.17750
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 = 332.954753682975, Press = 6.26241704159241
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    34941.471    34941.471    34769.859    34769.859    331.99446    331.99446    48998.554    48998.554   -494.24155   -494.24155 
   15000    34939.599    34939.599    34766.608    34766.608    334.66325    334.66325    48945.722    48945.722     592.8249     592.8249 
Loop time of 105.624 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.340 hours/ns, 9.468 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    | 104.61     | 104.61     | 104.61     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20228    | 0.20228    | 0.20228    |   0.0 |  0.19
Output  | 0.00017753 | 0.00017753 | 0.00017753 |   0.0 |  0.00
Modify  | 0.71025    | 0.71025    | 0.71025    |   0.0 |  0.67
Other   |            | 0.1027     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8245.00 ave        8245 max        8245 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:      957050.0 ave      957050 max      957050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957050
Ave neighs/atom = 239.26250
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 = 332.818545688655, Press = 4.41225487279172
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    34939.599    34939.599    34766.608    34766.608    334.66325    334.66325    48945.722    48945.722     592.8249     592.8249 
   16000    34944.089    34944.089    34772.659    34772.659    331.64429    331.64429     49018.64     49018.64   -510.54214   -510.54214 
Loop time of 105.597 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.333 hours/ns, 9.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    | 104.58     | 104.58     | 104.58     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20365    | 0.20365    | 0.20365    |   0.0 |  0.19
Output  | 0.00017598 | 0.00017598 | 0.00017598 |   0.0 |  0.00
Modify  | 0.71224    | 0.71224    | 0.71224    |   0.0 |  0.67
Other   |            | 0.1021     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8272.00 ave        8272 max        8272 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:      958110.0 ave      958110 max      958110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958110
Ave neighs/atom = 239.52750
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 = 332.759038412336, Press = -0.251030472044526
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    34944.089    34944.089    34772.659    34772.659    331.64429    331.64429     49018.64     49018.64   -510.54214   -510.54214 
   17000     34940.03     34940.03    34769.751    34769.751    329.41637    329.41637    49012.394    49012.394   -917.89246   -917.89246 
Loop time of 106.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.466 hours/ns, 9.427 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    | 105.05     | 105.05     | 105.05     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20404    | 0.20404    | 0.20404    |   0.0 |  0.19
Output  | 0.00022683 | 0.00022683 | 0.00022683 |   0.0 |  0.00
Modify  | 0.72279    | 0.72279    | 0.72279    |   0.0 |  0.68
Other   |            | 0.1028     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8247.00 ave        8247 max        8247 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:      956352.0 ave      956352 max      956352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956352
Ave neighs/atom = 239.08800
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 = 332.646323702695, Press = 2.8322217262101
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000     34940.03     34940.03    34769.751    34769.751    329.41637    329.41637    49012.394    49012.394   -917.89246   -917.89246 
   18000    34937.212    34937.212    34765.589    34765.589    332.01625    332.01625    48926.411    48926.411    884.61136    884.61136 
Loop time of 105.371 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.270 hours/ns, 9.490 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    | 104.36     | 104.36     | 104.36     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20236    | 0.20236    | 0.20236    |   0.0 |  0.19
Output  | 0.00022917 | 0.00022917 | 0.00022917 |   0.0 |  0.00
Modify  | 0.70894    | 0.70894    | 0.70894    |   0.0 |  0.67
Other   |            | 0.1016     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8237.00 ave        8237 max        8237 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:      956446.0 ave      956446 max      956446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956446
Ave neighs/atom = 239.11150
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 = 332.671417280352, Press = 4.98225108639315
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    34937.212    34937.212    34765.589    34765.589    332.01625    332.01625    48926.411    48926.411    884.61136    884.61136 
   19000    34943.187    34943.187    34770.975    34770.975    333.15602    333.15602     48950.57     48950.57    900.70791    900.70791 
Loop time of 104.822 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.117 hours/ns, 9.540 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    | 103.81     | 103.81     | 103.81     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20151    | 0.20151    | 0.20151    |   0.0 |  0.19
Output  | 0.00017588 | 0.00017588 | 0.00017588 |   0.0 |  0.00
Modify  | 0.7033     | 0.7033     | 0.7033     |   0.0 |  0.67
Other   |            | 0.1024     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8254.00 ave        8254 max        8254 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:      958138.0 ave      958138 max      958138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958138
Ave neighs/atom = 239.53450
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 = 332.558336684083, Press = -2.10068591751295
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    34943.187    34943.187    34770.975    34770.975    333.15602    333.15602     48950.57     48950.57    900.70791    900.70791 
   20000     34940.84     34940.84    34770.648    34770.648    329.24749    329.24749    49045.267    49045.267   -1352.8815   -1352.8815 
Loop time of 106.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.812 ns/day, 29.546 hours/ns, 9.402 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    | 105.33     | 105.33     | 105.33     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20539    | 0.20539    | 0.20539    |   0.0 |  0.19
Output  | 0.00022922 | 0.00022922 | 0.00022922 |   0.0 |  0.00
Modify  | 0.725      | 0.725      | 0.725      |   0.0 |  0.68
Other   |            | 0.1019     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8257.00 ave        8257 max        8257 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:      957810.0 ave      957810 max      957810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957810
Ave neighs/atom = 239.45250
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 = 332.553270034781, Press = 3.38227615760496
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000     34940.84     34940.84    34770.648    34770.648    329.24749    329.24749    49045.267    49045.267   -1352.8815   -1352.8815 
   21000    34945.514    34945.514    34770.235    34770.235    339.08766    339.08766    49025.918    49025.918   -946.83754   -946.83754 
Loop time of 105.326 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.257 hours/ns, 9.494 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    | 104.31     | 104.31     | 104.31     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20291    | 0.20291    | 0.20291    |   0.0 |  0.19
Output  | 0.00023089 | 0.00023089 | 0.00023089 |   0.0 |  0.00
Modify  | 0.71121    | 0.71121    | 0.71121    |   0.0 |  0.68
Other   |            | 0.1013     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8241.00 ave        8241 max        8241 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:      955620.0 ave      955620 max      955620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 955620
Ave neighs/atom = 238.90500
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 = 332.590546968952, Press = 3.25079244257001
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    34945.514    34945.514    34770.235    34770.235    339.08766    339.08766    49025.918    49025.918   -946.83754   -946.83754 
   22000    34940.392    34940.392    34767.009    34767.009     335.4228     335.4228    48974.808    48974.808   -51.241797   -51.241797 
Loop time of 105.906 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.418 hours/ns, 9.442 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    | 104.88     | 104.88     | 104.88     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20337    | 0.20337    | 0.20337    |   0.0 |  0.19
Output  | 0.00018214 | 0.00018214 | 0.00018214 |   0.0 |  0.00
Modify  | 0.71546    | 0.71546    | 0.71546    |   0.0 |  0.68
Other   |            | 0.1026     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8242.00 ave        8242 max        8242 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:      956330.0 ave      956330 max      956330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956330
Ave neighs/atom = 239.08250
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 = 332.643491864953, Press = 1.37886008720559
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    34940.392    34940.392    34767.009    34767.009     335.4228     335.4228    48974.808    48974.808   -51.241797   -51.241797 
   23000    34943.964    34943.964    34770.653    34770.653    335.28129    335.28129    49035.911    49035.911    -1066.648    -1066.648 
Loop time of 108.286 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.798 ns/day, 30.079 hours/ns, 9.235 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    | 107.23     | 107.23     | 107.23     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20781    | 0.20781    | 0.20781    |   0.0 |  0.19
Output  | 0.00022803 | 0.00022803 | 0.00022803 |   0.0 |  0.00
Modify  | 0.74104    | 0.74104    | 0.74104    |   0.0 |  0.68
Other   |            | 0.103      |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8244.00 ave        8244 max        8244 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:      957522.0 ave      957522 max      957522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957522
Ave neighs/atom = 239.38050
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 = 332.739551224287, Press = 3.93111508205664
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000    34943.964    34943.964    34770.653    34770.653    335.28129    335.28129    49035.911    49035.911    -1066.648    -1066.648 
   24000    34939.824    34939.824    34768.974    34768.974    330.52036    330.52036    48914.085    48914.085    1434.5697    1434.5697 
Loop time of 105.593 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.331 hours/ns, 9.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    | 104.57     | 104.57     | 104.57     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20409    | 0.20409    | 0.20409    |   0.0 |  0.19
Output  | 0.00017731 | 0.00017731 | 0.00017731 |   0.0 |  0.00
Modify  | 0.72087    | 0.72087    | 0.72087    |   0.0 |  0.68
Other   |            | 0.1024     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8269.00 ave        8269 max        8269 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:      956268.0 ave      956268 max      956268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956268
Ave neighs/atom = 239.06700
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 = 332.834163957713, Press = 4.27197714038738
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    34939.824    34939.824    34768.974    34768.974    330.52036    330.52036    48914.085    48914.085    1434.5697    1434.5697 
   25000    34943.264    34943.264     34769.78     34769.78    335.61732    335.61732    48894.422    48894.422    2116.2974    2116.2974 
Loop time of 103.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.832 ns/day, 28.856 hours/ns, 9.626 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    | 102.88     | 102.88     | 102.88     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2007     | 0.2007     | 0.2007     |   0.0 |  0.19
Output  | 0.00017492 | 0.00017492 | 0.00017492 |   0.0 |  0.00
Modify  | 0.69631    | 0.69631    | 0.69631    |   0.0 |  0.67
Other   |            | 0.101      |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8291.00 ave        8291 max        8291 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:      958686.0 ave      958686 max      958686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958686
Ave neighs/atom = 239.67150
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 = 332.869334816456, Press = -0.608320026027108
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    34943.264    34943.264     34769.78     34769.78    335.61732    335.61732    48894.422    48894.422    2116.2974    2116.2974 
   26000    34936.666    34936.666     34768.87     34768.87    324.61197    324.61197     49015.19     49015.19   -883.39054   -883.39054 
Loop time of 104.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.141 hours/ns, 9.532 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    | 103.89     | 103.89     | 103.89     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20234    | 0.20234    | 0.20234    |   0.0 |  0.19
Output  | 0.00017473 | 0.00017473 | 0.00017473 |   0.0 |  0.00
Modify  | 0.71267    | 0.71267    | 0.71267    |   0.0 |  0.68
Other   |            | 0.1021     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8303.00 ave        8303 max        8303 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:      958956.0 ave      958956 max      958956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958956
Ave neighs/atom = 239.73900
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 = 332.808990991803, Press = -0.0630102043313105
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    34936.666    34936.666     34768.87     34768.87    324.61197    324.61197     49015.19     49015.19   -883.39054   -883.39054 
   27000    34945.838    34945.838    34769.995    34769.995    340.18015    340.18015    48999.859    48999.859   -398.43328   -398.43328 
Loop time of 105.446 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.291 hours/ns, 9.484 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    | 104.42     | 104.42     | 104.42     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20502    | 0.20502    | 0.20502    |   0.0 |  0.19
Output  | 0.00019145 | 0.00019145 | 0.00019145 |   0.0 |  0.00
Modify  | 0.71645    | 0.71645    | 0.71645    |   0.0 |  0.68
Other   |            | 0.1025     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8289.00 ave        8289 max        8289 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:      956252.0 ave      956252 max      956252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956252
Ave neighs/atom = 239.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 = 332.837690828941, Press = 2.27806693551616
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000    34945.838    34945.838    34769.995    34769.995    340.18015    340.18015    48999.859    48999.859   -398.43328   -398.43328 
   28000    34939.785    34939.785    34767.661    34767.661    332.98444    332.98444    48967.369    48967.369   -122.31181   -122.31181 
Loop time of 104.846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.124 hours/ns, 9.538 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    | 103.84     | 103.84     | 103.84     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20236    | 0.20236    | 0.20236    |   0.0 |  0.19
Output  | 0.00017838 | 0.00017838 | 0.00017838 |   0.0 |  0.00
Modify  | 0.70461    | 0.70461    | 0.70461    |   0.0 |  0.67
Other   |            | 0.1024     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8261.00 ave        8261 max        8261 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:      956708.0 ave      956708 max      956708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956708
Ave neighs/atom = 239.17700
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 = 332.899574059838, Press = 1.26969420620772
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    34939.785    34939.785    34767.661    34767.661    332.98444    332.98444    48967.369    48967.369   -122.31181   -122.31181 
   29000    34942.698    34942.698    34771.074    34771.074    332.01772    332.01772    49076.376    49076.376    -2192.038    -2192.038 
Loop time of 106.138 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.483 hours/ns, 9.422 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    | 105.1      | 105.1      | 105.1      |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20765    | 0.20765    | 0.20765    |   0.0 |  0.20
Output  | 0.00017536 | 0.00017536 | 0.00017536 |   0.0 |  0.00
Modify  | 0.7231     | 0.7231     | 0.7231     |   0.0 |  0.68
Other   |            | 0.1027     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8283.00 ave        8283 max        8283 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:      957816.0 ave      957816 max      957816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957816
Ave neighs/atom = 239.45400
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 = 332.9334978543, Press = 1.31008923443656
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    34942.698    34942.698    34771.074    34771.074    332.01772    332.01772    49076.376    49076.376    -2192.038    -2192.038 
   30000    34949.599    34949.599    34774.297    34774.297    339.13268    339.13268    48979.876    48979.876    501.26395    501.26395 
Loop time of 105.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.211 hours/ns, 9.509 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    | 104.14     | 104.14     | 104.14     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20341    | 0.20341    | 0.20341    |   0.0 |  0.19
Output  | 0.000515   | 0.000515   | 0.000515   |   0.0 |  0.00
Modify  | 0.71194    | 0.71194    | 0.71194    |   0.0 |  0.68
Other   |            | 0.1022     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8250.00 ave        8250 max        8250 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:      955068.0 ave      955068 max      955068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 955068
Ave neighs/atom = 238.76700
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 = 332.965128376756, Press = 3.93414483807115
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    34949.599    34949.599    34774.297    34774.297    339.13268    339.13268    48979.876    48979.876    501.26395    501.26395 
   31000    34938.143    34938.143    34764.505    34764.505    335.91493    335.91493    48928.322    48928.322     698.4307     698.4307 
Loop time of 104.934 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.148 hours/ns, 9.530 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    | 103.92     | 103.92     | 103.92     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20279    | 0.20279    | 0.20279    |   0.0 |  0.19
Output  | 0.00017391 | 0.00017391 | 0.00017391 |   0.0 |  0.00
Modify  | 0.7086     | 0.7086     | 0.7086     |   0.0 |  0.68
Other   |            | 0.1022     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8265.00 ave        8265 max        8265 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:      956936.0 ave      956936 max      956936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956936
Ave neighs/atom = 239.23400
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 = 333.043106750079, Press = 0.96823882268648
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    34938.143    34938.143    34764.505    34764.505    335.91493    335.91493    48928.322    48928.322     698.4307     698.4307 
   32000    34940.582    34940.582    34769.419    34769.419    331.12576    331.12576    48975.406    48975.406     -14.4661     -14.4661 
Loop time of 106.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.809 ns/day, 29.649 hours/ns, 9.369 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    | 105.7      | 105.7      | 105.7      |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20594    | 0.20594    | 0.20594    |   0.0 |  0.19
Output  | 0.00017966 | 0.00017966 | 0.00017966 |   0.0 |  0.00
Modify  | 0.72478    | 0.72478    | 0.72478    |   0.0 |  0.68
Other   |            | 0.1029     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8263.00 ave        8263 max        8263 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:      958338.0 ave      958338 max      958338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958338
Ave neighs/atom = 239.58450
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 = 333.022768613008, Press = 0.943723345028326
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    34940.582    34940.582    34769.419    34769.419    331.12576    331.12576    48975.406    48975.406     -14.4661     -14.4661 
   33000    34936.858    34936.858    34770.434    34770.434    321.95779    321.95779    49044.955    49044.955   -1505.9095   -1505.9095 
Loop time of 106.745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.809 ns/day, 29.651 hours/ns, 9.368 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    | 105.7      | 105.7      | 105.7      |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20664    | 0.20664    | 0.20664    |   0.0 |  0.19
Output  | 0.00017681 | 0.00017681 | 0.00017681 |   0.0 |  0.00
Modify  | 0.7303     | 0.7303     | 0.7303     |   0.0 |  0.68
Other   |            | 0.1034     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8267.00 ave        8267 max        8267 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:      957424.0 ave      957424 max      957424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957424
Ave neighs/atom = 239.35600
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 = 332.955164278184, Press = 1.61447412525866
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    34936.858    34936.858    34770.434    34770.434    321.95779    321.95779    49044.955    49044.955   -1505.9095   -1505.9095 
   34000    34939.698    34939.698     34769.31     34769.31    329.62785    329.62785    48999.637    48999.637   -390.54201   -390.54201 
Loop time of 105.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.817 ns/day, 29.368 hours/ns, 9.459 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    | 104.7      | 104.7      | 104.7      |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20443    | 0.20443    | 0.20443    |   0.0 |  0.19
Output  | 0.00017705 | 0.00017705 | 0.00017705 |   0.0 |  0.00
Modify  | 0.71641    | 0.71641    | 0.71641    |   0.0 |  0.68
Other   |            | 0.1018     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8223.00 ave        8223 max        8223 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:      955974.0 ave      955974 max      955974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 955974
Ave neighs/atom = 238.99350
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 = 332.960757670339, Press = 3.37824212529978
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    34939.698    34939.698     34769.31     34769.31    329.62785    329.62785    48999.637    48999.637   -390.54201   -390.54201 
   35000      34947.2      34947.2    34769.415    34769.415    343.93677    343.93677    48949.431    48949.431    821.12717    821.12717 
Loop time of 106.233 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.813 ns/day, 29.509 hours/ns, 9.413 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    | 105.21     | 105.21     | 105.21     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20499    | 0.20499    | 0.20499    |   0.0 |  0.19
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.72047    | 0.72047    | 0.72047    |   0.0 |  0.68
Other   |            | 0.1016     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8238.00 ave        8238 max        8238 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:      956882.0 ave      956882 max      956882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956882
Ave neighs/atom = 239.22050
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 = 333.002368900222, Press = 1.28325604248672
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000      34947.2      34947.2    34769.415    34769.415    343.93677    343.93677    48949.431    48949.431    821.12717    821.12717 
   36000    34937.653    34937.653    34766.029    34766.029    332.01759    332.01759    48954.434    48954.434    172.72047    172.72047 
Loop time of 103.353 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.709 hours/ns, 9.676 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    | 102.36     | 102.36     | 102.36     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19805    | 0.19805    | 0.19805    |   0.0 |  0.19
Output  | 0.00017742 | 0.00017742 | 0.00017742 |   0.0 |  0.00
Modify  | 0.6933     | 0.6933     | 0.6933     |   0.0 |  0.67
Other   |            | 0.101      |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8248.00 ave        8248 max        8248 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:      957876.0 ave      957876 max      957876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957876
Ave neighs/atom = 239.46900
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 = 333.024145549887, Press = 1.05165268040363
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    34937.653    34937.653    34766.029    34766.029    332.01759    332.01759    48954.434    48954.434    172.72047    172.72047 
   37000    34943.352    34943.352    34770.195    34770.195    334.98389    334.98389     49021.33     49021.33   -922.26857   -922.26857 
Loop time of 103.605 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.779 hours/ns, 9.652 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    | 102.61     | 102.61     | 102.61     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20047    | 0.20047    | 0.20047    |   0.0 |  0.19
Output  | 0.00022744 | 0.00022744 | 0.00022744 |   0.0 |  0.00
Modify  | 0.69377    | 0.69377    | 0.69377    |   0.0 |  0.67
Other   |            | 0.1019     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8280.00 ave        8280 max        8280 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:      957914.0 ave      957914 max      957914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957914
Ave neighs/atom = 239.47850
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 = 333.073534746016, Press = 2.09809141703878
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    34943.352    34943.352    34770.195    34770.195    334.98389    334.98389     49021.33     49021.33   -922.26857   -922.26857 
   38000    34938.785    34938.785    34768.596    34768.596    329.24112    329.24112    48947.519    48947.519    595.53405    595.53405 
Loop time of 106.041 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.456 hours/ns, 9.430 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    | 105        | 105        | 105        |   0.0 | 99.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20638    | 0.20638    | 0.20638    |   0.0 |  0.19
Output  | 0.00022421 | 0.00022421 | 0.00022421 |   0.0 |  0.00
Modify  | 0.73073    | 0.73073    | 0.73073    |   0.0 |  0.69
Other   |            | 0.1026     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8266.00 ave        8266 max        8266 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:      956208.0 ave      956208 max      956208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956208
Ave neighs/atom = 239.05200
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 = 333.086790695983, Press = 1.19572742111799
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    34938.785    34938.785    34768.596    34768.596    329.24112    329.24112    48947.519    48947.519    595.53405    595.53405 
   39000     34945.69     34945.69    34770.658    34770.658     338.6126     338.6126    48984.109    48984.109    9.1668101    9.1668101 
Loop time of 104.946 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.152 hours/ns, 9.529 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    | 103.93     | 103.93     | 103.93     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20377    | 0.20377    | 0.20377    |   0.0 |  0.19
Output  | 0.00017483 | 0.00017483 | 0.00017483 |   0.0 |  0.00
Modify  | 0.7094     | 0.7094     | 0.7094     |   0.0 |  0.68
Other   |            | 0.1022     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8282.00 ave        8282 max        8282 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:      957922.0 ave      957922 max      957922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957922
Ave neighs/atom = 239.48050
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 = 333.15156291604, Press = 0.510224445207963
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000     34945.69     34945.69    34770.658    34770.658     338.6126     338.6126    48984.109    48984.109    9.1668101    9.1668101 
   40000    34941.554    34941.554     34769.42     34769.42    333.00417    333.00417    48940.664    48940.664    880.16681    880.16681 
Loop time of 104.429 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.008 hours/ns, 9.576 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    | 103.42     | 103.42     | 103.42     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20357    | 0.20357    | 0.20357    |   0.0 |  0.19
Output  | 0.00017907 | 0.00017907 | 0.00017907 |   0.0 |  0.00
Modify  | 0.70544    | 0.70544    | 0.70544    |   0.0 |  0.68
Other   |            | 0.1017     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8307.00 ave        8307 max        8307 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:      956910.0 ave      956910 max      956910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956910
Ave neighs/atom = 239.22750
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 = 333.171784101575, Press = 2.14118663396883
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    34941.554    34941.554     34769.42     34769.42    333.00417    333.00417    48940.664    48940.664    880.16681    880.16681 
   41000    34942.684    34942.684    34768.705    34768.705    336.57301    336.57301    48952.551    48952.551    687.81911    687.81911 
Loop time of 105.602 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.334 hours/ns, 9.469 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.58     | 104.58     | 104.58     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2059     | 0.2059     | 0.2059     |   0.0 |  0.19
Output  | 0.0002285  | 0.0002285  | 0.0002285  |   0.0 |  0.00
Modify  | 0.7163     | 0.7163     | 0.7163     |   0.0 |  0.68
Other   |            | 0.103      |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8270.00 ave        8270 max        8270 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:      957754.0 ave      957754 max      957754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957754
Ave neighs/atom = 239.43850
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 = 333.225589932748, Press = -0.359090884097197
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    34942.684    34942.684    34768.705    34768.705    336.57301    336.57301    48952.551    48952.551    687.81911    687.81911 
   42000    34942.472    34942.472    34768.288    34768.288    336.97141    336.97141    48967.527    48967.527    309.74694    309.74694 
Loop time of 103.57 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.769 hours/ns, 9.655 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    | 102.57     | 102.57     | 102.57     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20172    | 0.20172    | 0.20172    |   0.0 |  0.19
Output  | 0.00017643 | 0.00017643 | 0.00017643 |   0.0 |  0.00
Modify  | 0.69367    | 0.69367    | 0.69367    |   0.0 |  0.67
Other   |            | 0.102      |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8294.00 ave        8294 max        8294 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:      957710.0 ave      957710 max      957710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957710
Ave neighs/atom = 239.42750
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 = 333.198201640943, Press = 0.680089396563897
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000    34942.472    34942.472    34768.288    34768.288    336.97141    336.97141    48967.527    48967.527    309.74694    309.74694 
   43000    34935.371    34935.371    34768.118    34768.118    323.56171    323.56171    48968.169    48968.169   -60.522756   -60.522756 
Loop time of 107.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.806 ns/day, 29.773 hours/ns, 9.330 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    | 106.13     | 106.13     | 106.13     |   0.0 | 99.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20889    | 0.20889    | 0.20889    |   0.0 |  0.19
Output  | 0.00022921 | 0.00022921 | 0.00022921 |   0.0 |  0.00
Modify  | 0.7377     | 0.7377     | 0.7377     |   0.0 |  0.69
Other   |            | 0.1033     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8281.00 ave        8281 max        8281 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:      957392.0 ave      957392 max      957392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957392
Ave neighs/atom = 239.34800
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 = 333.175331969561, Press = 0.826550892405747
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000    34935.371    34935.371    34768.118    34768.118    323.56171    323.56171    48968.169    48968.169   -60.522756   -60.522756 
   44000    34944.532    34944.532    34770.947    34770.947    335.81232    335.81232     48948.56     48948.56    998.59089    998.59089 
Loop time of 104.783 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.106 hours/ns, 9.543 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    | 103.77     | 103.77     | 103.77     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20402    | 0.20402    | 0.20402    |   0.0 |  0.19
Output  | 0.00017696 | 0.00017696 | 0.00017696 |   0.0 |  0.00
Modify  | 0.70691    | 0.70691    | 0.70691    |   0.0 |  0.67
Other   |            | 0.1013     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8271.00 ave        8271 max        8271 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:      957732.0 ave      957732 max      957732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957732
Ave neighs/atom = 239.43300
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 = 333.161138793121, Press = 1.44040521725694
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000    34944.532    34944.532    34770.947    34770.947    335.81232    335.81232     48948.56     48948.56    998.59089    998.59089 
   45000    34940.816    34940.816    34771.832    34771.832    326.91097    326.91097    48931.897    48931.897     1440.718     1440.718 
Loop time of 104.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.054 hours/ns, 9.561 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    | 103.58     | 103.58     | 103.58     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20358    | 0.20358    | 0.20358    |   0.0 |  0.19
Output  | 0.0001785  | 0.0001785  | 0.0001785  |   0.0 |  0.00
Modify  | 0.70938    | 0.70938    | 0.70938    |   0.0 |  0.68
Other   |            | 0.1027     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8276.00 ave        8276 max        8276 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:      957714.0 ave      957714 max      957714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957714
Ave neighs/atom = 239.42850
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 = 333.160178389895, Press = 1.04316523596235
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    34940.816    34940.816    34771.832    34771.832    326.91097    326.91097    48931.897    48931.897     1440.718     1440.718 
   46000    34943.028    34943.028    34770.563    34770.563    333.64633    333.64633    49071.558    49071.558   -1820.5192   -1820.5192 
Loop time of 106.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.812 ns/day, 29.544 hours/ns, 9.402 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    | 105.32     | 105.32     | 105.32     |   0.0 | 99.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20731    | 0.20731    | 0.20731    |   0.0 |  0.19
Output  | 0.00021689 | 0.00021689 | 0.00021689 |   0.0 |  0.00
Modify  | 0.73076    | 0.73076    | 0.73076    |   0.0 |  0.69
Other   |            | 0.1025     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8282.00 ave        8282 max        8282 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:      958036.0 ave      958036 max      958036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 958036
Ave neighs/atom = 239.50900
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 = 333.182696286263, Press = -0.619201472786647
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000    34943.028    34943.028    34770.563    34770.563    333.64633    333.64633    49071.558    49071.558   -1820.5192   -1820.5192 
   47000     34939.81     34939.81    34769.607    34769.607    329.26783    329.26783    48996.243    48996.243   -595.90207   -595.90207 
Loop time of 105.344 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.262 hours/ns, 9.493 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    | 104.32     | 104.32     | 104.32     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20343    | 0.20343    | 0.20343    |   0.0 |  0.19
Output  | 0.00022814 | 0.00022814 | 0.00022814 |   0.0 |  0.00
Modify  | 0.71729    | 0.71729    | 0.71729    |   0.0 |  0.68
Other   |            | 0.1025     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8250.00 ave        8250 max        8250 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:      955140.0 ave      955140 max      955140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 955140
Ave neighs/atom = 238.78500
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 = 333.14018089176, Press = 1.87933305593343
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000     34939.81     34939.81    34769.607    34769.607    329.26783    329.26783    48996.243    48996.243   -595.90207   -595.90207 
   48000    34943.818    34943.818    34769.347    34769.347    337.52608    337.52608    48970.883    48970.883    351.48055    351.48055 
Loop time of 104.319 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.828 ns/day, 28.977 hours/ns, 9.586 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    | 103.31     | 103.31     | 103.31     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20037    | 0.20037    | 0.20037    |   0.0 |  0.19
Output  | 0.00017233 | 0.00017233 | 0.00017233 |   0.0 |  0.00
Modify  | 0.70709    | 0.70709    | 0.70709    |   0.0 |  0.68
Other   |            | 0.1023     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8262.00 ave        8262 max        8262 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:      957134.0 ave      957134 max      957134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957134
Ave neighs/atom = 239.28350
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 = 333.100081363792, Press = 0.852394632207446
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    34943.818    34943.818    34769.347    34769.347    337.52608    337.52608    48970.883    48970.883    351.48055    351.48055 
   49000    34938.963    34938.963    34765.386    34765.386    335.79705    335.79705    49015.034    49015.034   -1160.7146   -1160.7146 
Loop time of 103.213 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.837 ns/day, 28.670 hours/ns, 9.689 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    | 102.22     | 102.22     | 102.22     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19969    | 0.19969    | 0.19969    |   0.0 |  0.19
Output  | 0.00023229 | 0.00023229 | 0.00023229 |   0.0 |  0.00
Modify  | 0.6961     | 0.6961     | 0.6961     |   0.0 |  0.67
Other   |            | 0.102      |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8274.00 ave        8274 max        8274 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:      957362.0 ave      957362 max      957362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 957362
Ave neighs/atom = 239.34050
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 = 333.081048857175, Press = 1.62059971153545
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000    34938.963    34938.963    34765.386    34765.386    335.79705    335.79705    49015.034    49015.034   -1160.7146   -1160.7146 
   50000    34943.078    34943.078    34770.891    34770.891    333.10733    333.10733    48868.573    48868.573    2682.8977    2682.8977 
Loop time of 105.165 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.213 hours/ns, 9.509 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    | 104.15     | 104.15     | 104.15     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20279    | 0.20279    | 0.20279    |   0.0 |  0.19
Output  | 0.00017703 | 0.00017703 | 0.00017703 |   0.0 |  0.00
Modify  | 0.7117     | 0.7117     | 0.7117     |   0.0 |  0.68
Other   |            | 0.103      |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8240.00 ave        8240 max        8240 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:      956460.0 ave      956460 max      956460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 956460
Ave neighs/atom = 239.11500
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 = 333.08703053116, Press = 0.818233357950113
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 = 9
  ghost atom cutoff = 9
  binsize = 4.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 9
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    34943.078    34943.078    34770.891    34770.891    333.10733    333.10733    48868.573    48868.573    2682.8977    2682.8977 
   51000    34940.543    34940.543     34769.16     34769.16    331.55301    331.55301    48985.044    48985.044   -276.38693   -276.38693 
Loop time of 103.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.831 ns/day, 28.871 hours/ns, 9.621 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    | 102.94     | 102.94     | 102.94     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2005     | 0.2005     | 0.2005     |   0.0 |  0.19
Output  | 0.00017658 | 0.00017658 | 0.00017658 |   0.0 |  0.00
Modify  | 0.69638    | 0.69638    | 0.69638    |   0.0 |  0.67
Other   |            | 0.1022     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8256.00 ave        8256 max        8256 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:      959408.0 ave      959408 max      959408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959408
Ave neighs/atom = 239.85200
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
48979.3655748443

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0