# 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 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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     34736.06     34736.06    34584.528    34584.528       293.15       293.15    48129.511    48129.511    3362.8439    3362.8439 
    1000    34909.941    34909.941    34747.956    34747.956    313.37155    313.37155    48909.677    48909.677   -616.63145   -616.63145 
Loop time of 106.159 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.489 hours/ns, 9.420 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.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20378    | 0.20378    | 0.20378    |   0.0 |  0.19
Output  | 0.00022256 | 0.00022256 | 0.00022256 |   0.0 |  0.00
Modify  | 0.69501    | 0.69501    | 0.69501    |   0.0 |  0.65
Other   |            | 0.1038     |            |       |  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    34909.941    34909.941    34747.956    34747.956    313.37155    313.37155    48909.677    48909.677   -616.63145   -616.63145 
    2000    34896.262    34896.262    34742.697    34742.697    297.08223    297.08223    48850.054    48850.054   -423.34566   -423.34566 
Loop time of 106.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.813 ns/day, 29.529 hours/ns, 9.407 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.31     | 105.31     | 105.31     |   0.0 | 99.07
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20258    | 0.20258    | 0.20258    |   0.0 |  0.19
Output  | 0.00021194 | 0.00021194 | 0.00021194 |   0.0 |  0.00
Modify  | 0.68689    | 0.68689    | 0.68689    |   0.0 |  0.65
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:        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:      959152.0 ave      959152 max      959152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959152
Ave neighs/atom = 239.78800
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    34896.262    34896.262    34742.697    34742.697    297.08223    297.08223    48850.054    48850.054   -423.34566   -423.34566 
    3000    34898.334    34898.334    34744.923    34744.923    296.78484    296.78484    48835.602    48835.602    457.81856    457.81856 
Loop time of 107.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.805 ns/day, 29.822 hours/ns, 9.314 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.35     | 106.35     | 106.35     |   0.0 | 99.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20511    | 0.20511    | 0.20511    |   0.0 |  0.19
Output  | 0.00021358 | 0.00021358 | 0.00021358 |   0.0 |  0.00
Modify  | 0.70491    | 0.70491    | 0.70491    |   0.0 |  0.66
Other   |            | 0.1038     |            |       |  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:      961314.0 ave      961314 max      961314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961314
Ave neighs/atom = 240.32850
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    34898.334    34898.334    34744.923    34744.923    296.78484    296.78484    48835.602    48835.602    457.81856    457.81856 
    4000    34894.833    34894.833    34744.589    34744.589    290.65669    290.65669    48863.167    48863.167   -512.47208   -512.47208 
Loop time of 106.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.455 hours/ns, 9.431 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.04     | 105.04     | 105.04     |   0.0 | 99.06
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20166    | 0.20166    | 0.20166    |   0.0 |  0.19
Output  | 0.00021404 | 0.00021404 | 0.00021404 |   0.0 |  0.00
Modify  | 0.69455    | 0.69455    | 0.69455    |   0.0 |  0.65
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:        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:      961476.0 ave      961476 max      961476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961476
Ave neighs/atom = 240.36900
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.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 
    4000    34894.833    34894.833    34744.589    34744.589    290.65669    290.65669    48863.167    48863.167   -512.47208   -512.47208 
    5000    34899.607    34899.607    34747.753    34747.753    293.77134    293.77134    48901.908    48901.908   -839.53204   -839.53204 
Loop time of 107.421 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.804 ns/day, 29.839 hours/ns, 9.309 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.4      | 106.4      | 106.4      |   0.0 | 99.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20709    | 0.20709    | 0.20709    |   0.0 |  0.19
Output  | 0.0002326  | 0.0002326  | 0.0002326  |   0.0 |  0.00
Modify  | 0.70995    | 0.70995    | 0.70995    |   0.0 |  0.66
Other   |            | 0.1039     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8300.00 ave        8300 max        8300 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:      960632.0 ave      960632 max      960632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960632
Ave neighs/atom = 240.15800
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 = 293.954172402241, Press = -509.791398187914
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 
    5000    34899.607    34899.607    34747.753    34747.753    293.77134    293.77134    48901.908    48901.908   -839.53204   -839.53204 
    6000    34895.164    34895.164    34745.805    34745.805    288.94468    288.94468    48860.816    48860.816   -268.98347   -268.98347 
Loop time of 105.335 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.260 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.32     | 104.32     | 104.32     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20277    | 0.20277    | 0.20277    |   0.0 |  0.19
Output  | 0.0001773  | 0.0001773  | 0.0001773  |   0.0 |  0.00
Modify  | 0.71128    | 0.71128    | 0.71128    |   0.0 |  0.68
Other   |            | 0.1032     |            |       |  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:      959450.0 ave      959450 max      959450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959450
Ave neighs/atom = 239.86250
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 = 293.196349411855, Press = -22.5031524326796
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    34895.164    34895.164    34745.805    34745.805    288.94468    288.94468    48860.816    48860.816   -268.98347   -268.98347 
    7000    34899.251    34899.251     34747.34     34747.34    293.88162    293.88162    48875.462    48875.462   -482.10253   -482.10253 
Loop time of 105.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.336 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.59     | 104.59     | 104.59     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20165    | 0.20165    | 0.20165    |   0.0 |  0.19
Output  | 0.00022632 | 0.00022632 | 0.00022632 |   0.0 |  0.00
Modify  | 0.71199    | 0.71199    | 0.71199    |   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:        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:      960918.0 ave      960918 max      960918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960918
Ave neighs/atom = 240.22950
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 = 293.165589448443, Press = -22.003431232857
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    34899.251    34899.251     34747.34     34747.34    293.88162    293.88162    48875.462    48875.462   -482.10253   -482.10253 
    8000    34895.225    34895.225    34744.725    34744.725    291.15129    291.15129    48820.462    48820.462    645.44919    645.44919 
Loop time of 106.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.812 ns/day, 29.570 hours/ns, 9.394 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.42     | 105.42     | 105.42     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20424    | 0.20424    | 0.20424    |   0.0 |  0.19
Output  | 0.00022458 | 0.00022458 | 0.00022458 |   0.0 |  0.00
Modify  | 0.72669    | 0.72669    | 0.72669    |   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:        8259.00 ave        8259 max        8259 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:      960570.0 ave      960570 max      960570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960570
Ave neighs/atom = 240.14250
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 = 292.92433805231, Press = -12.8655338448631
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 
    8000    34895.225    34895.225    34744.725    34744.725    291.15129    291.15129    48820.462    48820.462    645.44919    645.44919 
    9000    34899.301    34899.301    34744.685    34744.685    299.11454    299.11454    48793.478    48793.478    1325.9287    1325.9287 
Loop time of 105.492 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.303 hours/ns, 9.479 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.48     | 104.48     | 104.48     |   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.00018137 | 0.00018137 | 0.00018137 |   0.0 |  0.00
Modify  | 0.71012    | 0.71012    | 0.71012    |   0.0 |  0.67
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:        8275.00 ave        8275 max        8275 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:      961432.0 ave      961432 max      961432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961432
Ave neighs/atom = 240.35800
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 = 292.992030673971, Press = -3.76658374668242
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    34899.301    34899.301    34744.685    34744.685    299.11454    299.11454    48793.478    48793.478    1325.9287    1325.9287 
   10000    34895.503    34895.503    34741.577    34741.577    297.78112    297.78112    48827.623    48827.623    83.922309    83.922309 
Loop time of 105.801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.817 ns/day, 29.389 hours/ns, 9.452 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.78     | 104.78     | 104.78     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20336    | 0.20336    | 0.20336    |   0.0 |  0.19
Output  | 0.00017566 | 0.00017566 | 0.00017566 |   0.0 |  0.00
Modify  | 0.71614    | 0.71614    | 0.71614    |   0.0 |  0.68
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:        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:      962306.0 ave      962306 max      962306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 962306
Ave neighs/atom = 240.57650
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 = 292.73742165279, Press = 2.76071732198904
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    34895.503    34895.503    34741.577    34741.577    297.78112    297.78112    48827.623    48827.623    83.922309    83.922309 
   11000    34900.167    34900.167    34747.669    34747.669    295.01719    295.01719    48886.334    48886.334   -613.86729   -613.86729 
Loop time of 105.379 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.272 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.20285    | 0.20285    | 0.20285    |   0.0 |  0.19
Output  | 0.00017363 | 0.00017363 | 0.00017363 |   0.0 |  0.00
Modify  | 0.7111     | 0.7111     | 0.7111     |   0.0 |  0.67
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:        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:      962108.0 ave      962108 max      962108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 962108
Ave neighs/atom = 240.52700
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 = 292.619609753951, Press = 2.27073012645293
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    34900.167    34900.167    34747.669    34747.669    295.01719    295.01719    48886.334    48886.334   -613.86729   -613.86729 
   12000    34898.491    34898.491    34745.398    34745.398     296.1687     296.1687    48866.733    48866.733   -358.48939   -358.48939 
Loop time of 105.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.212 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.20274    | 0.20274    | 0.20274    |   0.0 |  0.19
Output  | 0.00017744 | 0.00017744 | 0.00017744 |   0.0 |  0.00
Modify  | 0.71167    | 0.71167    | 0.71167    |   0.0 |  0.68
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:        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:      960058.0 ave      960058 max      960058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960058
Ave neighs/atom = 240.01450
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 = 292.683697499873, Press = -2.37564800038022
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 
   12000    34898.491    34898.491    34745.398    34745.398     296.1687     296.1687    48866.733    48866.733   -358.48939   -358.48939 
   13000    34896.234    34896.234    34743.398    34743.398    295.67175    295.67175    48881.234    48881.234   -994.90599   -994.90599 
Loop time of 104.343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.828 ns/day, 28.984 hours/ns, 9.584 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.34     | 103.34     | 103.34     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19937    | 0.19937    | 0.19937    |   0.0 |  0.19
Output  | 0.00022322 | 0.00022322 | 0.00022322 |   0.0 |  0.00
Modify  | 0.70017    | 0.70017    | 0.70017    |   0.0 |  0.67
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:        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:      960574.0 ave      960574 max      960574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960574
Ave neighs/atom = 240.14350
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 = 292.654845687578, Press = -0.41444628250883
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    34896.234    34896.234    34743.398    34743.398    295.67175    295.67175    48881.234    48881.234   -994.90599   -994.90599 
   14000    34898.429    34898.429    34748.416    34748.416    290.20994    290.20994    48905.276    48905.276   -956.43655   -956.43655 
Loop time of 105.042 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.178 hours/ns, 9.520 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.03     | 104.03     | 104.03     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20098    | 0.20098    | 0.20098    |   0.0 |  0.19
Output  | 0.00017298 | 0.00017298 | 0.00017298 |   0.0 |  0.00
Modify  | 0.70606    | 0.70606    | 0.70606    |   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:        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:      960600.0 ave      960600 max      960600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960600
Ave neighs/atom = 240.15000
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 = 292.909996803764, Press = -0.356830800717344
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    34898.429    34898.429    34748.416    34748.416    290.20994    290.20994    48905.276    48905.276   -956.43655   -956.43655 
   15000    34897.191    34897.191    34747.396    34747.396    289.78808    289.78808      48937.2      48937.2   -1963.5908   -1963.5908 
Loop time of 104.658 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.072 hours/ns, 9.555 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.65     | 103.65     | 103.65     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20127    | 0.20127    | 0.20127    |   0.0 |  0.19
Output  | 0.0001762  | 0.0001762  | 0.0001762  |   0.0 |  0.00
Modify  | 0.70478    | 0.70478    | 0.70478    |   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:        8278.00 ave        8278 max        8278 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:      959726.0 ave      959726 max      959726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959726
Ave neighs/atom = 239.93150
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 = 292.902071319064, Press = -2.78866152588582
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    34897.191    34897.191    34747.396    34747.396    289.78808    289.78808      48937.2      48937.2   -1963.5908   -1963.5908 
   16000    34900.494    34900.494    34746.392    34746.392    298.12045    298.12045    48930.014    48930.014   -1717.7854   -1717.7854 
Loop time of 105.824 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.396 hours/ns, 9.450 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.8      | 104.8      | 104.8      |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20295    | 0.20295    | 0.20295    |   0.0 |  0.19
Output  | 0.00022276 | 0.00022276 | 0.00022276 |   0.0 |  0.00
Modify  | 0.71664    | 0.71664    | 0.71664    |   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:        8260.00 ave        8260 max        8260 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:      959116.0 ave      959116 max      959116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959116
Ave neighs/atom = 239.77900
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 = 292.915805292412, Press = -4.09174679812186
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    34900.494    34900.494    34746.392    34746.392    298.12045    298.12045    48930.014    48930.014   -1717.7854   -1717.7854 
   17000    34894.762    34894.762    34742.202    34742.202    295.13898    295.13898    48886.749    48886.749   -1130.0579   -1130.0579 
Loop time of 106.854 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.809 ns/day, 29.682 hours/ns, 9.359 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.82     | 105.82     | 105.82     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20532    | 0.20532    | 0.20532    |   0.0 |  0.19
Output  | 0.00017404 | 0.00017404 | 0.00017404 |   0.0 |  0.00
Modify  | 0.72937    | 0.72937    | 0.72937    |   0.0 |  0.68
Other   |            | 0.1036     |            |       |  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:      959050.0 ave      959050 max      959050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959050
Ave neighs/atom = 239.76250
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 = 292.916940680803, Press = -6.81567031582029
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    34894.762    34894.762    34742.202    34742.202    295.13898    295.13898    48886.749    48886.749   -1130.0579   -1130.0579 
   18000     34899.91     34899.91    34746.135    34746.135     297.4889     297.4889    48804.356    48804.356    1252.7943    1252.7943 
Loop time of 105.317 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.255 hours/ns, 9.495 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.3      | 104.3      | 104.3      |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20072    | 0.20072    | 0.20072    |   0.0 |  0.19
Output  | 0.00018447 | 0.00018447 | 0.00018447 |   0.0 |  0.00
Modify  | 0.71186    | 0.71186    | 0.71186    |   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:        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:      960138.0 ave      960138 max      960138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960138
Ave neighs/atom = 240.03450
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 = 292.932165593257, Press = -4.25736193134594
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     34899.91     34899.91    34746.135    34746.135     297.4889     297.4889    48804.356    48804.356    1252.7943    1252.7943 
   19000    34896.876    34896.876    34744.253    34744.253    295.26057    295.26057    48789.591    48789.591    1267.9939    1267.9939 
Loop time of 104.628 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.063 hours/ns, 9.558 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.62     | 103.62     | 103.62     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20059    | 0.20059    | 0.20059    |   0.0 |  0.19
Output  | 0.00017994 | 0.00017994 | 0.00017994 |   0.0 |  0.00
Modify  | 0.70171    | 0.70171    | 0.70171    |   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:        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:      961922.0 ave      961922 max      961922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961922
Ave neighs/atom = 240.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 = 292.89783637219, Press = -3.88923103303097
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    34896.876    34896.876    34744.253    34744.253    295.26057    295.26057    48789.591    48789.591    1267.9939    1267.9939 
   20000    34896.139    34896.139    34742.927    34742.927    296.39857    296.39857    48822.111    48822.111    448.55779    448.55779 
Loop time of 106.695 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.810 ns/day, 29.638 hours/ns, 9.372 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.66     | 105.66     | 105.66     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20382    | 0.20382    | 0.20382    |   0.0 |  0.19
Output  | 0.00017465 | 0.00017465 | 0.00017465 |   0.0 |  0.00
Modify  | 0.72741    | 0.72741    | 0.72741    |   0.0 |  0.68
Other   |            | 0.1037     |            |       |  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:      962418.0 ave      962418 max      962418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 962418
Ave neighs/atom = 240.60450
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 = 292.997145363665, Press = -1.39671570221694
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    34896.139    34896.139    34742.927    34742.927    296.39857    296.39857    48822.111    48822.111    448.55779    448.55779 
   21000    34897.122    34897.122    34747.066    34747.066    290.29227    290.29227    48819.413    48819.413    887.28973    887.28973 
Loop time of 105.635 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.61     | 104.61     | 104.61     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20245    | 0.20245    | 0.20245    |   0.0 |  0.19
Output  | 0.00017869 | 0.00017869 | 0.00017869 |   0.0 |  0.00
Modify  | 0.71642    | 0.71642    | 0.71642    |   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:        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:      961634.0 ave      961634 max      961634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961634
Ave neighs/atom = 240.40850
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 = 292.943377315943, Press = 0.71455293913578
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    34897.122    34897.122    34747.066    34747.066    290.29227    290.29227    48819.413    48819.413    887.28973    887.28973 
   22000    34894.551    34894.551    34743.419    34743.419    292.37444    292.37444    48835.256    48835.256    140.62429    140.62429 
Loop time of 105.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.817 ns/day, 29.377 hours/ns, 9.456 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.73     | 104.73     | 104.73     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20243    | 0.20243    | 0.20243    |   0.0 |  0.19
Output  | 0.00022802 | 0.00022802 | 0.00022802 |   0.0 |  0.00
Modify  | 0.71781    | 0.71781    | 0.71781    |   0.0 |  0.68
Other   |            | 0.1035     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8255.00 ave        8255 max        8255 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:      961220.0 ave      961220 max      961220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961220
Ave neighs/atom = 240.30500
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 = 292.959984649815, Press = -1.43987616650367
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    34894.551    34894.551    34743.419    34743.419    292.37444    292.37444    48835.256    48835.256    140.62429    140.62429 
   23000    34896.418    34896.418    34745.126    34745.126    292.68337    292.68337      48936.4      48936.4   -2160.0396   -2160.0396 
Loop time of 107.773 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.802 ns/day, 29.937 hours/ns, 9.279 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.71     | 106.71     | 106.71     |   0.0 | 99.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20639    | 0.20639    | 0.20639    |   0.0 |  0.19
Output  | 0.00023523 | 0.00023523 | 0.00023523 |   0.0 |  0.00
Modify  | 0.74712    | 0.74712    | 0.74712    |   0.0 |  0.69
Other   |            | 0.1045     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8235.00 ave        8235 max        8235 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:      961720.0 ave      961720 max      961720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961720
Ave neighs/atom = 240.43000
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 = 293.028772630699, Press = -1.47794051284777
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    34896.418    34896.418    34745.126    34745.126    292.68337    292.68337      48936.4      48936.4   -2160.0396   -2160.0396 
   24000    34898.742    34898.742      34745.8      34745.8    295.87724    295.87724    48899.546    48899.546   -937.70211   -937.70211 
Loop time of 104.741 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.095 hours/ns, 9.547 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.73     | 103.73     | 103.73     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19987    | 0.19987    | 0.19987    |   0.0 |  0.19
Output  | 0.0002177  | 0.0002177  | 0.0002177  |   0.0 |  0.00
Modify  | 0.70753    | 0.70753    | 0.70753    |   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:        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:      959140.0 ave      959140 max      959140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959140
Ave neighs/atom = 239.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 = 293.078596008558, Press = -3.89069833587212
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 
   24000    34898.742    34898.742      34745.8      34745.8    295.87724    295.87724    48899.546    48899.546   -937.70211   -937.70211 
   25000    34894.863    34894.863    34744.483    34744.483    290.92034    290.92034    48823.301    48823.301    457.54618    457.54618 
Loop time of 104.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.058 hours/ns, 9.559 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.6      | 103.6      | 103.6      |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20049    | 0.20049    | 0.20049    |   0.0 |  0.19
Output  | 0.00017724 | 0.00017724 | 0.00017724 |   0.0 |  0.00
Modify  | 0.70587    | 0.70587    | 0.70587    |   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:        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:      959584.0 ave      959584 max      959584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959584
Ave neighs/atom = 239.89600
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 = 293.054584714401, Press = -1.7687183120158
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 
   25000    34894.863    34894.863    34744.483    34744.483    290.92034    290.92034    48823.301    48823.301    457.54618    457.54618 
   26000     34895.42     34895.42    34744.457    34744.457    292.04792    292.04792    48774.633    48774.633    1616.8938    1616.8938 
Loop time of 104.493 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.026 hours/ns, 9.570 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.48     | 103.48     | 103.48     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20101    | 0.20101    | 0.20101    |   0.0 |  0.19
Output  | 0.00017686 | 0.00017686 | 0.00017686 |   0.0 |  0.00
Modify  | 0.7056     | 0.7056     | 0.7056     |   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:        8258.00 ave        8258 max        8258 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:      961622.0 ave      961622 max      961622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961622
Ave neighs/atom = 240.40550
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 = 293.203629296897, Press = -1.54067644697287
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 
   26000     34895.42     34895.42    34744.457    34744.457    292.04792    292.04792    48774.633    48774.633    1616.8938    1616.8938 
   27000    34900.254    34900.254    34745.915    34745.915    298.57983    298.57983    48823.233    48823.233    689.69289    689.69289 
Loop time of 106.105 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.474 hours/ns, 9.425 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.08     | 105.08     | 105.08     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20208    | 0.20208    | 0.20208    |   0.0 |  0.19
Output  | 0.00017744 | 0.00017744 | 0.00017744 |   0.0 |  0.00
Modify  | 0.71916    | 0.71916    | 0.71916    |   0.0 |  0.68
Other   |            | 0.1037     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8255.00 ave        8255 max        8255 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:      962932.0 ave      962932 max      962932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 962932
Ave neighs/atom = 240.73300
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 = 293.241124311446, Press = -0.604957668374301
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    34900.254    34900.254    34745.915    34745.915    298.57983    298.57983    48823.233    48823.233    689.69289    689.69289 
   28000    34896.209    34896.209    34744.092    34744.092    294.28051    294.28051    48833.593    48833.593    322.06337    322.06337 
Loop time of 105.526 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.313 hours/ns, 9.476 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.51     | 104.51     | 104.51     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20306    | 0.20306    | 0.20306    |   0.0 |  0.19
Output  | 0.00018384 | 0.00018384 | 0.00018384 |   0.0 |  0.00
Modify  | 0.71085    | 0.71085    | 0.71085    |   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:        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:      961426.0 ave      961426 max      961426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961426
Ave neighs/atom = 240.35650
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 = 293.2167333994, Press = -0.879445425840016
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    34896.209    34896.209    34744.092    34744.092    294.28051    294.28051    48833.593    48833.593    322.06337    322.06337 
   29000    34900.055    34900.055    34746.348    34746.348    297.35637    297.35637    48861.644    48861.644   -110.57056   -110.57056 
Loop time of 105.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.817 ns/day, 29.393 hours/ns, 9.451 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.79     | 104.79     | 104.79     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20224    | 0.20224    | 0.20224    |   0.0 |  0.19
Output  | 0.00022592 | 0.00022592 | 0.00022592 |   0.0 |  0.00
Modify  | 0.71652    | 0.71652    | 0.71652    |   0.0 |  0.68
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:        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:      961504.0 ave      961504 max      961504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961504
Ave neighs/atom = 240.37600
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 = 293.305556852747, Press = -0.849652894905065
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 
   29000    34900.055    34900.055    34746.348    34746.348    297.35637    297.35637    48861.644    48861.644   -110.57056   -110.57056 
   30000    34897.314    34897.314    34743.216    34743.216    298.11348    298.11348    48808.717    48808.717    736.22312    736.22312 
Loop time of 105.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.425 hours/ns, 9.440 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.9      | 104.9      | 104.9      |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20569    | 0.20569    | 0.20569    |   0.0 |  0.19
Output  | 0.00044267 | 0.00044267 | 0.00044267 |   0.0 |  0.00
Modify  | 0.72215    | 0.72215    | 0.72215    |   0.0 |  0.68
Other   |            | 0.104      |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8300.00 ave        8300 max        8300 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:      960810.0 ave      960810 max      960810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960810
Ave neighs/atom = 240.20250
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 = 293.304140120537, Press = 0.332470605531197
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    34897.314    34897.314    34743.216    34743.216    298.11348    298.11348    48808.717    48808.717    736.22312    736.22312 
   31000    34898.425    34898.425    34748.494    34748.494    290.05165    290.05165    48838.764    48838.764    658.79064    658.79064 
Loop time of 104.621 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.061 hours/ns, 9.558 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.61     | 103.61     | 103.61     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19999    | 0.19999    | 0.19999    |   0.0 |  0.19
Output  | 0.00017534 | 0.00017534 | 0.00017534 |   0.0 |  0.00
Modify  | 0.70374    | 0.70374    | 0.70374    |   0.0 |  0.67
Other   |            | 0.1035     |            |       |  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:      961820.0 ave      961820 max      961820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961820
Ave neighs/atom = 240.45500
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 = 293.366276529053, Press = -1.12617032575963
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 
   31000    34898.425    34898.425    34748.494    34748.494    290.05165    290.05165    48838.764    48838.764    658.79064    658.79064 
   32000    34900.631    34900.631    34747.385    34747.385    296.46433    296.46433    48908.308    48908.308    -1102.608    -1102.608 
Loop time of 105.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.422 hours/ns, 9.441 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.89     | 104.89     | 104.89     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.204      | 0.204      | 0.204      |   0.0 |  0.19
Output  | 0.0002285  | 0.0002285  | 0.0002285  |   0.0 |  0.00
Modify  | 0.72147    | 0.72147    | 0.72147    |   0.0 |  0.68
Other   |            | 0.1032     |            |       |  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:      960946.0 ave      960946 max      960946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960946
Ave neighs/atom = 240.23650
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 = 293.385665565491, Press = 0.562224909956653
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    34900.631    34900.631    34747.385    34747.385    296.46433    296.46433    48908.308    48908.308    -1102.608    -1102.608 
   33000    34894.888    34894.888    34743.345    34743.345     293.1712     293.1712    48881.985    48881.985   -887.52708   -887.52708 
Loop time of 106.058 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.461 hours/ns, 9.429 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.03     | 105.03     | 105.03     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20299    | 0.20299    | 0.20299    |   0.0 |  0.19
Output  | 0.00017539 | 0.00017539 | 0.00017539 |   0.0 |  0.00
Modify  | 0.72265    | 0.72265    | 0.72265    |   0.0 |  0.68
Other   |            | 0.1035     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8251.00 ave        8251 max        8251 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:      959726.0 ave      959726 max      959726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959726
Ave neighs/atom = 239.93150
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 = 293.448623549523, Press = -0.842461298518265
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    34894.888    34894.888    34743.345    34743.345     293.1712     293.1712    48881.985    48881.985   -887.52708   -887.52708 
   34000    34900.339    34900.339    34746.063    34746.063    298.45767    298.45767    48885.818    48885.818   -503.24318   -503.24318 
Loop time of 107.208 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.806 ns/day, 29.780 hours/ns, 9.328 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.17     | 106.17     | 106.17     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20685    | 0.20685    | 0.20685    |   0.0 |  0.19
Output  | 0.00017688 | 0.00017688 | 0.00017688 |   0.0 |  0.00
Modify  | 0.73206    | 0.73206    | 0.73206    |   0.0 |  0.68
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:        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:      960788.0 ave      960788 max      960788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960788
Ave neighs/atom = 240.19700
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 = 293.438916166244, Press = -0.621583790143168
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    34900.339    34900.339    34746.063    34746.063    298.45767    298.45767    48885.818    48885.818   -503.24318   -503.24318 
   35000    34897.542    34897.542    34746.167    34746.167    292.84584    292.84584    48866.383    48866.383   -274.56184   -274.56184 
Loop time of 105.385 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.274 hours/ns, 9.489 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.37     | 104.37     | 104.37     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20192    | 0.20192    | 0.20192    |   0.0 |  0.19
Output  | 0.00018014 | 0.00018014 | 0.00018014 |   0.0 |  0.00
Modify  | 0.71225    | 0.71225    | 0.71225    |   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:        8252.00 ave        8252 max        8252 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:      960158.0 ave      960158 max      960158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960158
Ave neighs/atom = 240.03950
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 = 293.420196264874, Press = -0.203776328626315
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    34897.542    34897.542    34746.167    34746.167    292.84584    292.84584    48866.383    48866.383   -274.56184   -274.56184 
   36000    34891.822    34891.822    34743.686    34743.686    286.57958    286.57958    48877.808    48877.808   -937.22886   -937.22886 
Loop time of 103.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.839 ns/day, 28.618 hours/ns, 9.706 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.03     | 102.03     | 102.03     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19896    | 0.19896    | 0.19896    |   0.0 |  0.19
Output  | 0.00017849 | 0.00017849 | 0.00017849 |   0.0 |  0.00
Modify  | 0.69006    | 0.69006    | 0.69006    |   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:        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:      960544.0 ave      960544 max      960544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960544
Ave neighs/atom = 240.13600
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 = 293.385933651979, Press = 0.545111661343533
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    34891.822    34891.822    34743.686    34743.686    286.57958    286.57958    48877.808    48877.808   -937.22886   -937.22886 
   37000    34901.021    34901.021    34747.125    34747.125     297.7223     297.7223    48910.987    48910.987   -1192.3403   -1192.3403 
Loop time of 103.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.837 ns/day, 28.689 hours/ns, 9.682 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.29     | 102.29     | 102.29     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19721    | 0.19721    | 0.19721    |   0.0 |  0.19
Output  | 0.00017582 | 0.00017582 | 0.00017582 |   0.0 |  0.00
Modify  | 0.68934    | 0.68934    | 0.68934    |   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:        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:      960452.0 ave      960452 max      960452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960452
Ave neighs/atom = 240.11300
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 = 293.369171162476, Press = -0.508586444331742
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    34901.021    34901.021    34747.125    34747.125     297.7223     297.7223    48910.987    48910.987   -1192.3403   -1192.3403 
   38000    34896.643    34896.643    34745.513    34745.513    292.37196    292.37196    48938.324    48938.324   -1986.5136   -1986.5136 
Loop time of 106.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.812 ns/day, 29.568 hours/ns, 9.395 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.41     | 105.41     | 105.41     |   0.0 | 99.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20557    | 0.20557    | 0.20557    |   0.0 |  0.19
Output  | 0.00017596 | 0.00017596 | 0.00017596 |   0.0 |  0.00
Modify  | 0.72891    | 0.72891    | 0.72891    |   0.0 |  0.68
Other   |            | 0.1043     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8268.00 ave        8268 max        8268 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:      959612.0 ave      959612 max      959612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959612
Ave neighs/atom = 239.90300
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 = 293.380393875185, Press = -0.914131920796054
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    34896.643    34896.643    34745.513    34745.513    292.37196    292.37196    48938.324    48938.324   -1986.5136   -1986.5136 
   39000    34898.901    34898.901    34746.772    34746.772      294.304      294.304    48897.084    48897.084    -1053.048    -1053.048 
Loop time of 105.846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.402 hours/ns, 9.448 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.82     | 104.82     | 104.82     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20287    | 0.20287    | 0.20287    |   0.0 |  0.19
Output  | 0.0002304  | 0.0002304  | 0.0002304  |   0.0 |  0.00
Modify  | 0.72386    | 0.72386    | 0.72386    |   0.0 |  0.68
Other   |            | 0.1032     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8249.00 ave        8249 max        8249 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:      959108.0 ave      959108 max      959108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959108
Ave neighs/atom = 239.77700
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 = 293.438154793025, Press = -3.20568304516547
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 
   39000    34898.901    34898.901    34746.772    34746.772      294.304      294.304    48897.084    48897.084    -1053.048    -1053.048 
   40000    34899.153    34899.153    34749.156    34749.156    290.18048    290.18048    48882.484    48882.484   -301.41008   -301.41008 
Loop time of 105.084 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.190 hours/ns, 9.516 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.07     | 104.07     | 104.07     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2011     | 0.2011     | 0.2011     |   0.0 |  0.19
Output  | 0.00027334 | 0.00027334 | 0.00027334 |   0.0 |  0.00
Modify  | 0.7134     | 0.7134     | 0.7134     |   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:        8236.00 ave        8236 max        8236 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:      960006.0 ave      960006 max      960006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960006
Ave neighs/atom = 240.00150
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 = 293.424300344316, Press = -1.25030080918443
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    34899.153    34899.153    34749.156    34749.156    290.18048    290.18048    48882.484    48882.484   -301.41008   -301.41008 
   41000    34901.008    34901.008    34745.616    34745.616    300.61615    300.61615    48846.047    48846.047    264.39605    264.39605 
Loop time of 105.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.325 hours/ns, 9.472 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.02
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20282    | 0.20282    | 0.20282    |   0.0 |  0.19
Output  | 0.00028105 | 0.00028105 | 0.00028105 |   0.0 |  0.00
Modify  | 0.72362    | 0.72362    | 0.72362    |   0.0 |  0.69
Other   |            | 0.1037     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8246.00 ave        8246 max        8246 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:      959984.0 ave      959984 max      959984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 959984
Ave neighs/atom = 239.99600
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 = 293.446212246417, Press = -1.39572733543454
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 
   41000    34901.008    34901.008    34745.616    34745.616    300.61615    300.61615    48846.047    48846.047    264.39605    264.39605 
   42000    34896.604    34896.604    34747.266    34747.266    288.90337    288.90337    48834.641    48834.641    553.41318    553.41318 
Loop time of 104.149 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.830 ns/day, 28.930 hours/ns, 9.602 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.15     | 103.15     | 103.15     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19905    | 0.19905    | 0.19905    |   0.0 |  0.19
Output  | 0.00017589 | 0.00017589 | 0.00017589 |   0.0 |  0.00
Modify  | 0.70051    | 0.70051    | 0.70051    |   0.0 |  0.67
Other   |            | 0.1036     |            |       |  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:      960992.0 ave      960992 max      960992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960992
Ave neighs/atom = 240.24800
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 = 293.448104343481, Press = -0.80599884575717
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    34896.604    34896.604    34747.266    34747.266    288.90337    288.90337    48834.641    48834.641    553.41318    553.41318 
   43000    34896.324    34896.324    34746.737    34746.737    289.38671    289.38671    48877.248    48877.248   -453.91212   -453.91212 
Loop time of 105.632 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.6      | 104.6      | 104.6      |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20447    | 0.20447    | 0.20447    |   0.0 |  0.19
Output  | 0.00023284 | 0.00023284 | 0.00023284 |   0.0 |  0.00
Modify  | 0.72108    | 0.72108    | 0.72108    |   0.0 |  0.68
Other   |            | 0.1038     |            |       |  0.10

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8246.00 ave        8246 max        8246 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:      960888.0 ave      960888 max      960888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960888
Ave neighs/atom = 240.22200
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 = 293.456813692383, Press = -2.48893368174528
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    34896.324    34896.324    34746.737    34746.737    289.38671    289.38671    48877.248    48877.248   -453.91212   -453.91212 
   44000    34892.169    34892.169    34744.459    34744.459    285.75493    285.75493     48832.96     48832.96    80.100372    80.100372 
Loop time of 104.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.096 hours/ns, 9.547 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.73     | 103.73     | 103.73     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20272    | 0.20272    | 0.20272    |   0.0 |  0.19
Output  | 0.00022378 | 0.00022378 | 0.00022378 |   0.0 |  0.00
Modify  | 0.708      | 0.708      | 0.708      |   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:        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:      960080.0 ave      960080 max      960080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 960080
Ave neighs/atom = 240.02000
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 = 293.43730020813, Press = -3.21094035469737
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    34892.169    34892.169    34744.459    34744.459    285.75493    285.75493     48832.96     48832.96    80.100372    80.100372 
   45000    34899.498    34899.498    34744.991    34744.991    298.90358    298.90358    48817.259    48817.259    787.66886    787.66886 
Loop time of 103.733 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.815 hours/ns, 9.640 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.74     | 102.74     | 102.74     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19785    | 0.19785    | 0.19785    |   0.0 |  0.19
Output  | 0.00022612 | 0.00022612 | 0.00022612 |   0.0 |  0.00
Modify  | 0.69392    | 0.69392    | 0.69392    |   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:        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:      961566.0 ave      961566 max      961566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961566
Ave neighs/atom = 240.39150
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 = 293.40329730013, Press = -1.4470243764815
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    34899.498    34899.498    34744.991    34744.991    298.90358    298.90358    48817.259    48817.259    787.66886    787.66886 
   46000    34893.078    34893.078    34742.058    34742.058    292.15794    292.15794    48766.189    48766.189    1586.8843    1586.8843 
Loop time of 106.466 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.812 ns/day, 29.574 hours/ns, 9.393 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.43     | 105.43     | 105.43     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20352    | 0.20352    | 0.20352    |   0.0 |  0.19
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.7237     | 0.7237     | 0.7237     |   0.0 |  0.68
Other   |            | 0.1036     |            |       |  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:      961652.0 ave      961652 max      961652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 961652
Ave neighs/atom = 240.41300
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 = 293.356067187659, Press = -0.887218693572773
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 
   46000    34893.078    34893.078    34742.058    34742.058    292.15794    292.15794    48766.189    48766.189    1586.8843    1586.8843 
   47000    34897.821    34897.821     34748.12     34748.12    289.60744    289.60744    48793.973    48793.973    1484.7912    1484.7912 
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.20023    | 0.20023    | 0.20023    |   0.0 |  0.19
Output  | 0.00017616 | 0.00017616 | 0.00017616 |   0.0 |  0.00
Modify  | 0.69068    | 0.69068    | 0.69068    |   0.0 |  0.67
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:        8314.00 ave        8314 max        8314 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:      963188.0 ave      963188 max      963188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 963188
Ave neighs/atom = 240.79700
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 = 293.3249280493, Press = -0.844515955445185
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 
   47000    34897.821    34897.821     34748.12     34748.12    289.60744    289.60744    48793.973    48793.973    1484.7912    1484.7912 
   48000    34897.639    34897.639    34745.108    34745.108    295.07983    295.07983    48802.266    48802.266    1008.9999    1008.9999 
Loop time of 104.54 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.039 hours/ns, 9.566 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.53     | 103.53     | 103.53     |   0.0 | 99.03
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2022     | 0.2022     | 0.2022     |   0.0 |  0.19
Output  | 0.00017768 | 0.00017768 | 0.00017768 |   0.0 |  0.00
Modify  | 0.70713    | 0.70713    | 0.70713    |   0.0 |  0.68
Other   |            | 0.1035     |            |       |  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:      962202.0 ave      962202 max      962202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 962202
Ave neighs/atom = 240.55050
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 = 293.333791268544, Press = -0.537953217370036
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    34897.639    34897.639    34745.108    34745.108    295.07983    295.07983    48802.266    48802.266    1008.9999    1008.9999 
   49000    34899.318    34899.318    34748.328    34748.328     292.1005     292.1005    48849.852    48849.852    196.78528    196.78528 
Loop time of 104.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.043 hours/ns, 9.564 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.55     | 103.55     | 103.55     |   0.0 | 99.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20134    | 0.20134    | 0.20134    |   0.0 |  0.19
Output  | 0.00017488 | 0.00017488 | 0.00017488 |   0.0 |  0.00
Modify  | 0.70444    | 0.70444    | 0.70444    |   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:        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:      962282.0 ave      962282 max      962282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 962282
Ave neighs/atom = 240.57050
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
48854.9546570806

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0