# 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.5181212425231942*${_u_distance}
variable latticeconst_converted equal 3.5181212425231942*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.51812124252319
Lattice spacing in x,y,z = 3.5181212 3.5181212 3.5181212
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 (35.181212 35.181212 35.181212)
  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 (35.181212 35.181212 35.181212)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_PanBorovikovMendelev_2108_AgNi__MO_222110751402_000
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43544.4095973917 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_222110751402_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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17390.503   -17390.503   -17542.035   -17542.035       293.15       293.15     43544.41     43544.41    3716.8055    3716.8055 
    1000   -17233.133   -17233.133   -17385.042   -17385.042    293.87826    293.87826    43824.502    43824.502    2530.1236    2530.1236 
Loop time of 110.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.780 ns/day, 30.773 hours/ns, 9.027 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    | 109.82     | 109.82     | 109.82     |   0.0 | 99.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19338    | 0.19338    | 0.19338    |   0.0 |  0.17
Output  | 0.00021577 | 0.00021577 | 0.00021577 |   0.0 |  0.00
Modify  | 0.67085    | 0.67085    | 0.67085    |   0.0 |  0.61
Other   |            | 0.103      |            |       |  0.09

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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
    1000   -17233.133   -17233.133   -17385.042   -17385.042    293.87826    293.87826    43824.502    43824.502    2530.1236    2530.1236 
    2000   -17241.646   -17241.646   -17389.814   -17389.814    286.64163    286.64163     43878.22     43878.22    29.151221    29.151221 
Loop time of 115.597 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.747 ns/day, 32.110 hours/ns, 8.651 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    | 114.61     | 114.61     | 114.61     |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20253    | 0.20253    | 0.20253    |   0.0 |  0.18
Output  | 0.0002165  | 0.0002165  | 0.0002165  |   0.0 |  0.00
Modify  | 0.67878    | 0.67878    | 0.67878    |   0.0 |  0.59
Other   |            | 0.1036     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8308.00 ave        8308 max        8308 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:      967924.0 ave      967924 max      967924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967924
Ave neighs/atom = 241.98100
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17241.646   -17241.646   -17389.814   -17389.814    286.64163    286.64163     43878.22     43878.22    29.151221    29.151221 
    3000   -17241.318   -17241.318   -17391.284   -17391.284    290.11898    290.11898    43899.029    43899.029   -910.98686   -910.98686 
Loop time of 117.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.735 ns/day, 32.639 hours/ns, 8.511 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.5      | 116.5      | 116.5      |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2023     | 0.2023     | 0.2023     |   0.0 |  0.17
Output  | 0.00026698 | 0.00026698 | 0.00026698 |   0.0 |  0.00
Modify  | 0.69105    | 0.69105    | 0.69105    |   0.0 |  0.59
Other   |            | 0.1036     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8283.00 ave        8283 max        8283 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      967128.0 ave      967128 max      967128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967128
Ave neighs/atom = 241.78200
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
    3000   -17241.318   -17241.318   -17391.284   -17391.284    290.11898    290.11898    43899.029    43899.029   -910.98686   -910.98686 
    4000    -17237.75    -17237.75   -17387.651   -17387.651    289.99301    289.99301    43887.027    43887.027   -158.64565   -158.64565 
Loop time of 114.403 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.779 hours/ns, 8.741 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    | 113.42     | 113.42     | 113.42     |   0.0 | 99.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19934    | 0.19934    | 0.19934    |   0.0 |  0.17
Output  | 0.0002219  | 0.0002219  | 0.0002219  |   0.0 |  0.00
Modify  | 0.67673    | 0.67673    | 0.67673    |   0.0 |  0.59
Other   |            | 0.104      |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8310.00 ave        8310 max        8310 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:      966790.0 ave      966790 max      966790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966790
Ave neighs/atom = 241.69750
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -17237.75    -17237.75   -17387.651   -17387.651    289.99301    289.99301    43887.027    43887.027   -158.64565   -158.64565 
    5000   -17242.891   -17242.891   -17393.722   -17393.722     291.7925     291.7925    43862.832    43862.832    445.59336    445.59336 
Loop time of 114.598 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.833 hours/ns, 8.726 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    | 113.61     | 113.61     | 113.61     |   0.0 | 99.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20059    | 0.20059    | 0.20059    |   0.0 |  0.18
Output  | 0.00017254 | 0.00017254 | 0.00017254 |   0.0 |  0.00
Modify  | 0.68708    | 0.68708    | 0.68708    |   0.0 |  0.60
Other   |            | 0.1034     |            |       |  0.09

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:      966600.0 ave      966600 max      966600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966600
Ave neighs/atom = 241.65000
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 = 291.037324318981, Press = 241.719395374219
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17242.891   -17242.891   -17393.722   -17393.722     291.7925     291.7925    43862.832    43862.832    445.59336    445.59336 
    6000   -17238.608   -17238.608   -17389.123   -17389.123    291.18239    291.18239    43846.548    43846.548    1368.7803    1368.7803 
Loop time of 114.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.695 hours/ns, 8.764 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    | 113.1      | 113.1      | 113.1      |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19801    | 0.19801    | 0.19801    |   0.0 |  0.17
Output  | 0.00021743 | 0.00021743 | 0.00021743 |   0.0 |  0.00
Modify  | 0.69867    | 0.69867    | 0.69867    |   0.0 |  0.61
Other   |            | 0.1022     |            |       |  0.09

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:      967996.0 ave      967996 max      967996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967996
Ave neighs/atom = 241.99900
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.662096229545, Press = 11.2263788327445
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
    6000   -17238.608   -17238.608   -17389.123   -17389.123    291.18239    291.18239    43846.548    43846.548    1368.7803    1368.7803 
    7000   -17243.381   -17243.381   -17391.483   -17391.483    286.51279    286.51279    43872.322    43872.322     58.51426     58.51426 
Loop time of 113.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.760 ns/day, 31.566 hours/ns, 8.800 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    | 112.64     | 112.64     | 112.64     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1994     | 0.1994     | 0.1994     |   0.0 |  0.18
Output  | 0.00017991 | 0.00017991 | 0.00017991 |   0.0 |  0.00
Modify  | 0.69593    | 0.69593    | 0.69593    |   0.0 |  0.61
Other   |            | 0.1028     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8312.00 ave        8312 max        8312 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:      967626.0 ave      967626 max      967626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967626
Ave neighs/atom = 241.90650
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.009686573058, Press = -9.88790960917297
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
    7000   -17243.381   -17243.381   -17391.483   -17391.483    286.51279    286.51279    43872.322    43872.322     58.51426     58.51426 
    8000   -17239.238   -17239.238   -17388.433   -17388.433    288.62878    288.62878    43921.436    43921.436   -1669.5863   -1669.5863 
Loop time of 114.001 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.667 hours/ns, 8.772 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.99     | 112.99     | 112.99     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19923    | 0.19923    | 0.19923    |   0.0 |  0.17
Output  | 0.0001768  | 0.0001768  | 0.0001768  |   0.0 |  0.00
Modify  | 0.7043     | 0.7043     | 0.7043     |   0.0 |  0.62
Other   |            | 0.1033     |            |       |  0.09

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:      967140.0 ave      967140 max      967140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967140
Ave neighs/atom = 241.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 = 292.767085944025, Press = -12.4725873535798
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17239.238   -17239.238   -17388.433   -17388.433    288.62878    288.62878    43921.436    43921.436   -1669.5863   -1669.5863 
    9000   -17241.836   -17241.836   -17395.311   -17395.311     296.9077     296.9077    43954.762    43954.762    -3094.149    -3094.149 
Loop time of 113.535 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.761 ns/day, 31.538 hours/ns, 8.808 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    | 112.54     | 112.54     | 112.54     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19923    | 0.19923    | 0.19923    |   0.0 |  0.18
Output  | 0.00022912 | 0.00022912 | 0.00022912 |   0.0 |  0.00
Modify  | 0.69413    | 0.69413    | 0.69413    |   0.0 |  0.61
Other   |            | 0.1032     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8306.00 ave        8306 max        8306 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:      966052.0 ave      966052 max      966052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966052
Ave neighs/atom = 241.51300
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.110845725644, Press = 3.39990053619769
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
    9000   -17241.836   -17241.836   -17395.311   -17395.311     296.9077     296.9077    43954.762    43954.762    -3094.149    -3094.149 
   10000   -17238.566   -17238.566   -17390.626   -17390.626    294.16903    294.16903    43895.746    43895.746   -618.11649   -618.11649 
Loop time of 112.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.264 hours/ns, 8.885 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.56     | 111.56     | 111.56     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19773    | 0.19773    | 0.19773    |   0.0 |  0.18
Output  | 0.00017431 | 0.00017431 | 0.00017431 |   0.0 |  0.00
Modify  | 0.693      | 0.693      | 0.693      |   0.0 |  0.62
Other   |            | 0.1014     |            |       |  0.09

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:      965254.0 ave      965254 max      965254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 965254
Ave neighs/atom = 241.31350
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.214309368004, Press = 10.093281043686
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   10000   -17238.566   -17238.566   -17390.626   -17390.626    294.16903    294.16903    43895.746    43895.746   -618.11649   -618.11649 
   11000   -17238.381   -17238.381   -17391.589   -17391.589    296.39116    296.39116    43859.237    43859.237    839.70703    839.70703 
Loop time of 113.47 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.761 ns/day, 31.520 hours/ns, 8.813 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    | 112.47     | 112.47     | 112.47     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19918    | 0.19918    | 0.19918    |   0.0 |  0.18
Output  | 0.00022092 | 0.00022092 | 0.00022092 |   0.0 |  0.00
Modify  | 0.69385    | 0.69385    | 0.69385    |   0.0 |  0.61
Other   |            | 0.1031     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8292.00 ave        8292 max        8292 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:      966684.0 ave      966684 max      966684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966684
Ave neighs/atom = 241.67100
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.115481799418, Press = 3.82845785601782
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   11000   -17238.381   -17238.381   -17391.589   -17391.589    296.39116    296.39116    43859.237    43859.237    839.70703    839.70703 
   12000   -17237.525   -17237.525   -17393.072   -17393.072    300.91621    300.91621    43873.836    43873.836    98.699037    98.699037 
Loop time of 113.97 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.658 hours/ns, 8.774 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    | 112.97     | 112.97     | 112.97     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2002     | 0.2002     | 0.2002     |   0.0 |  0.18
Output  | 0.00017914 | 0.00017914 | 0.00017914 |   0.0 |  0.00
Modify  | 0.70017    | 0.70017    | 0.70017    |   0.0 |  0.61
Other   |            | 0.1028     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8316.00 ave        8316 max        8316 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      967562.0 ave      967562 max      967562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967562
Ave neighs/atom = 241.89050
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.375799014952, Press = -0.827796885086139
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17237.525   -17237.525   -17393.072   -17393.072    300.91621    300.91621    43873.836    43873.836    98.699037    98.699037 
   13000   -17237.325   -17237.325   -17390.456   -17390.456    296.24157    296.24157     43898.47     43898.47   -789.01662   -789.01662 
Loop time of 113.21 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.763 ns/day, 31.447 hours/ns, 8.833 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    | 112.22     | 112.22     | 112.22     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19812    | 0.19812    | 0.19812    |   0.0 |  0.18
Output  | 0.00017665 | 0.00017665 | 0.00017665 |   0.0 |  0.00
Modify  | 0.69365    | 0.69365    | 0.69365    |   0.0 |  0.61
Other   |            | 0.1028     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8302.00 ave        8302 max        8302 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:      967664.0 ave      967664 max      967664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967664
Ave neighs/atom = 241.91600
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.408089425291, Press = -10.140865526854
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   13000   -17237.325   -17237.325   -17390.456   -17390.456    296.24157    296.24157     43898.47     43898.47   -789.01662   -789.01662 
   14000    -17237.67    -17237.67   -17389.451   -17389.451    293.62946    293.62946    43953.457    43953.457   -2792.1776   -2792.1776 
Loop time of 113.016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.764 ns/day, 31.393 hours/ns, 8.848 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    | 112.02     | 112.02     | 112.02     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19734    | 0.19734    | 0.19734    |   0.0 |  0.17
Output  | 0.00017742 | 0.00017742 | 0.00017742 |   0.0 |  0.00
Modify  | 0.69257    | 0.69257    | 0.69257    |   0.0 |  0.61
Other   |            | 0.1029     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8296.00 ave        8296 max        8296 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:      966906.0 ave      966906 max      966906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966906
Ave neighs/atom = 241.72650
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.364617093783, Press = -2.11616552920914
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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    -17237.67    -17237.67   -17389.451   -17389.451    293.62946    293.62946    43953.457    43953.457   -2792.1776   -2792.1776 
   15000   -17234.528   -17234.528   -17385.728   -17385.728    292.50519    292.50519    43897.186    43897.186   -544.80262   -544.80262 
Loop time of 110.852 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.779 ns/day, 30.792 hours/ns, 9.021 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    | 109.87     | 109.87     | 109.87     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19681    | 0.19681    | 0.19681    |   0.0 |  0.18
Output  | 0.00022589 | 0.00022589 | 0.00022589 |   0.0 |  0.00
Modify  | 0.68443    | 0.68443    | 0.68443    |   0.0 |  0.62
Other   |            | 0.1017     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8285.00 ave        8285 max        8285 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:      965162.0 ave      965162 max      965162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 965162
Ave neighs/atom = 241.29050
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.344407544409, Press = 2.554352371488
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   15000   -17234.528   -17234.528   -17385.728   -17385.728    292.50519    292.50519    43897.186    43897.186   -544.80262   -544.80262 
   16000   -17239.596   -17239.596   -17392.381   -17392.381    295.57253    295.57253    43893.758    43893.758   -754.30876   -754.30876 
Loop time of 111.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.773 ns/day, 31.064 hours/ns, 8.942 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    | 110.84     | 110.84     | 110.84     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19837    | 0.19837    | 0.19837    |   0.0 |  0.18
Output  | 0.00022284 | 0.00022284 | 0.00022284 |   0.0 |  0.00
Modify  | 0.68742    | 0.68742    | 0.68742    |   0.0 |  0.61
Other   |            | 0.1017     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8312.00 ave        8312 max        8312 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:      966642.0 ave      966642 max      966642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966642
Ave neighs/atom = 241.66050
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.512565661682, Press = 1.42295584672713
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   16000   -17239.596   -17239.596   -17392.381   -17392.381    295.57253    295.57253    43893.758    43893.758   -754.30876   -754.30876 
   17000   -17236.015   -17236.015   -17389.467   -17389.467    296.86316    296.86316     43891.32     43891.32   -336.24593   -336.24593 
Loop time of 111.618 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.774 ns/day, 31.005 hours/ns, 8.959 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    | 110.63     | 110.63     | 110.63     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19637    | 0.19637    | 0.19637    |   0.0 |  0.18
Output  | 0.00022126 | 0.00022126 | 0.00022126 |   0.0 |  0.00
Modify  | 0.68826    | 0.68826    | 0.68826    |   0.0 |  0.62
Other   |            | 0.1028     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8299.00 ave        8299 max        8299 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:      967196.0 ave      967196 max      967196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967196
Ave neighs/atom = 241.79900
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.558098243827, Press = 2.70938877948444
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   17000   -17236.015   -17236.015   -17389.467   -17389.467    296.86316    296.86316     43891.32     43891.32   -336.24593   -336.24593 
   18000   -17240.467   -17240.467   -17392.304   -17392.304    293.73921    293.73921    43849.832    43849.832    1076.3524    1076.3524 
Loop time of 112.772 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.326 hours/ns, 8.867 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    | 111.77     | 111.77     | 111.77     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19774    | 0.19774    | 0.19774    |   0.0 |  0.18
Output  | 0.00017359 | 0.00017359 | 0.00017359 |   0.0 |  0.00
Modify  | 0.69745    | 0.69745    | 0.69745    |   0.0 |  0.62
Other   |            | 0.1032     |            |       |  0.09

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:      966810.0 ave      966810 max      966810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966810
Ave neighs/atom = 241.70250
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.634291010102, Press = 4.45412704798179
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   18000   -17240.467   -17240.467   -17392.304   -17392.304    293.73921    293.73921    43849.832    43849.832    1076.3524    1076.3524 
   19000   -17237.784   -17237.784   -17389.343   -17389.343    293.20163    293.20163    43808.877    43808.877    2747.7718    2747.7718 
Loop time of 111.415 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.775 ns/day, 30.949 hours/ns, 8.975 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.43     | 110.43     | 110.43     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1958     | 0.1958     | 0.1958     |   0.0 |  0.18
Output  | 0.00017738 | 0.00017738 | 0.00017738 |   0.0 |  0.00
Modify  | 0.68883    | 0.68883    | 0.68883    |   0.0 |  0.62
Other   |            | 0.1021     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8290.00 ave        8290 max        8290 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      967788.0 ave      967788 max      967788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967788
Ave neighs/atom = 241.94700
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.572599637739, Press = 1.10866989590675
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   19000   -17237.784   -17237.784   -17389.343   -17389.343    293.20163    293.20163    43808.877    43808.877    2747.7718    2747.7718 
   20000   -17237.337   -17237.337   -17389.232   -17389.232    293.85072    293.85072    43856.983    43856.983    996.43258    996.43258 
Loop time of 112.241 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.178 hours/ns, 8.909 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    | 111.25     | 111.25     | 111.25     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19627    | 0.19627    | 0.19627    |   0.0 |  0.17
Output  | 0.00022868 | 0.00022868 | 0.00022868 |   0.0 |  0.00
Modify  | 0.68882    | 0.68882    | 0.68882    |   0.0 |  0.61
Other   |            | 0.1032     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8321.00 ave        8321 max        8321 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:      968562.0 ave      968562 max      968562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 968562
Ave neighs/atom = 242.14050
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.566712747668, Press = -1.99112786143134
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   20000   -17237.337   -17237.337   -17389.232   -17389.232    293.85072    293.85072    43856.983    43856.983    996.43258    996.43258 
   21000   -17239.157   -17239.157   -17392.336   -17392.336     296.3352     296.3352    43874.913    43874.913    78.073571    78.073571 
Loop time of 111.872 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.772 ns/day, 31.076 hours/ns, 8.939 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    | 110.89     | 110.89     | 110.89     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19721    | 0.19721    | 0.19721    |   0.0 |  0.18
Output  | 0.00022269 | 0.00022269 | 0.00022269 |   0.0 |  0.00
Modify  | 0.68622    | 0.68622    | 0.68622    |   0.0 |  0.61
Other   |            | 0.1028     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8305.00 ave        8305 max        8305 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:      967456.0 ave      967456 max      967456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967456
Ave neighs/atom = 241.86400
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.45089271762, Press = -1.16073594150003
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17239.157   -17239.157   -17392.336   -17392.336     296.3352     296.3352    43874.913    43874.913    78.073571    78.073571 
   22000   -17237.437   -17237.437   -17392.008   -17392.008    299.02731    299.02731    43907.687    43907.687   -1064.1192   -1064.1192 
Loop time of 112.55 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.264 hours/ns, 8.885 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.56     | 111.56     | 111.56     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19717    | 0.19717    | 0.19717    |   0.0 |  0.18
Output  | 0.00017199 | 0.00017199 | 0.00017199 |   0.0 |  0.00
Modify  | 0.69203    | 0.69203    | 0.69203    |   0.0 |  0.61
Other   |            | 0.1026     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8277.00 ave        8277 max        8277 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:      967622.0 ave      967622 max      967622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967622
Ave neighs/atom = 241.90550
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.396095765337, Press = -1.38633175654098
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   22000   -17237.437   -17237.437   -17392.008   -17392.008    299.02731    299.02731    43907.687    43907.687   -1064.1192   -1064.1192 
   23000   -17240.767   -17240.767    -17392.35    -17392.35     293.2461     293.2461    43930.501    43930.501   -2051.4341   -2051.4341 
Loop time of 112.503 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.251 hours/ns, 8.889 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    | 111.51     | 111.51     | 111.51     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19934    | 0.19934    | 0.19934    |   0.0 |  0.18
Output  | 0.00017978 | 0.00017978 | 0.00017978 |   0.0 |  0.00
Modify  | 0.69383    | 0.69383    | 0.69383    |   0.0 |  0.62
Other   |            | 0.1032     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8306.00 ave        8306 max        8306 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:      966482.0 ave      966482 max      966482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966482
Ave neighs/atom = 241.62050
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.393439438617, Press = 0.682782896504984
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17240.767   -17240.767    -17392.35    -17392.35     293.2461     293.2461    43930.501    43930.501   -2051.4341   -2051.4341 
   24000   -17239.145   -17239.145    -17389.32    -17389.32    290.52325    290.52325    43888.359    43888.359   -383.44833   -383.44833 
Loop time of 111.745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.773 ns/day, 31.040 hours/ns, 8.949 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    | 110.75     | 110.75     | 110.75     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19758    | 0.19758    | 0.19758    |   0.0 |  0.18
Output  | 0.00017756 | 0.00017756 | 0.00017756 |   0.0 |  0.00
Modify  | 0.69025    | 0.69025    | 0.69025    |   0.0 |  0.62
Other   |            | 0.1022     |            |       |  0.09

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:      966364.0 ave      966364 max      966364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966364
Ave neighs/atom = 241.59100
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.483406458638, Press = 3.82343981426657
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17239.145   -17239.145    -17389.32    -17389.32    290.52325    290.52325    43888.359    43888.359   -383.44833   -383.44833 
   25000   -17239.777   -17239.777   -17391.268   -17391.268    293.06844    293.06844    43844.648    43844.648    1322.7314    1322.7314 
Loop time of 113.003 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.390 hours/ns, 8.849 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    | 112.01     | 112.01     | 112.01     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19857    | 0.19857    | 0.19857    |   0.0 |  0.18
Output  | 0.00017673 | 0.00017673 | 0.00017673 |   0.0 |  0.00
Modify  | 0.69522    | 0.69522    | 0.69522    |   0.0 |  0.62
Other   |            | 0.103      |            |       |  0.09

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:      967180.0 ave      967180 max      967180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967180
Ave neighs/atom = 241.79500
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.538446012027, Press = 2.72290107090942
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17239.777   -17239.777   -17391.268   -17391.268    293.06844    293.06844    43844.648    43844.648    1322.7314    1322.7314 
   26000   -17240.091   -17240.091   -17388.487   -17388.487     287.0811     287.0811    43834.271    43834.271    1790.3559    1790.3559 
Loop time of 110.96 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.779 ns/day, 30.822 hours/ns, 9.012 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    | 109.97     | 109.97     | 109.97     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.198      | 0.198      | 0.198      |   0.0 |  0.18
Output  | 0.00017803 | 0.00017803 | 0.00017803 |   0.0 |  0.00
Modify  | 0.6855     | 0.6855     | 0.6855     |   0.0 |  0.62
Other   |            | 0.1018     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8329.00 ave        8329 max        8329 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:      967832.0 ave      967832 max      967832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967832
Ave neighs/atom = 241.95800
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.561317950978, Press = 0.491380835469693
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17240.091   -17240.091   -17388.487   -17388.487     287.0811     287.0811    43834.271    43834.271    1790.3559    1790.3559 
   27000   -17241.888   -17241.888    -17393.12    -17393.12    292.56858    292.56858     43855.72     43855.72    738.75912    738.75912 
Loop time of 111.425 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.775 ns/day, 30.951 hours/ns, 8.975 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.44     | 110.44     | 110.44     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19649    | 0.19649    | 0.19649    |   0.0 |  0.18
Output  | 0.00017634 | 0.00017634 | 0.00017634 |   0.0 |  0.00
Modify  | 0.68756    | 0.68756    | 0.68756    |   0.0 |  0.62
Other   |            | 0.1021     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8287.00 ave        8287 max        8287 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      968088.0 ave      968088 max      968088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 968088
Ave neighs/atom = 242.02200
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.481424119491, Press = -0.561564405319197
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   27000   -17241.888   -17241.888    -17393.12    -17393.12    292.56858    292.56858     43855.72     43855.72    738.75912    738.75912 
   28000   -17240.628   -17240.628   -17388.028   -17388.028    285.15599    285.15599    43879.739    43879.739   -59.357306   -59.357306 
Loop time of 111.841 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.773 ns/day, 31.067 hours/ns, 8.941 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    | 110.85     | 110.85     | 110.85     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19881    | 0.19881    | 0.19881    |   0.0 |  0.18
Output  | 0.00022697 | 0.00022697 | 0.00022697 |   0.0 |  0.00
Modify  | 0.69306    | 0.69306    | 0.69306    |   0.0 |  0.62
Other   |            | 0.1029     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8317.00 ave        8317 max        8317 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:      967752.0 ave      967752 max      967752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967752
Ave neighs/atom = 241.93800
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.426467700086, Press = -0.577441489680347
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   28000   -17240.628   -17240.628   -17388.028   -17388.028    285.15599    285.15599    43879.739    43879.739   -59.357306   -59.357306 
   29000   -17237.661   -17237.661   -17388.258   -17388.258    291.33912    291.33912    43906.479    43906.479   -872.46335   -872.46335 
Loop time of 112.205 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.168 hours/ns, 8.912 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.21     | 111.21     | 111.21     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19927    | 0.19927    | 0.19927    |   0.0 |  0.18
Output  | 0.00027897 | 0.00027897 | 0.00027897 |   0.0 |  0.00
Modify  | 0.69048    | 0.69048    | 0.69048    |   0.0 |  0.62
Other   |            | 0.1027     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8303.00 ave        8303 max        8303 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      967052.0 ave      967052 max      967052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967052
Ave neighs/atom = 241.76300
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.351973554439, Press = 0.615119631240362
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17237.661   -17237.661   -17388.258   -17388.258    291.33912    291.33912    43906.479    43906.479   -872.46335   -872.46335 
   30000   -17242.114   -17242.114   -17391.742   -17391.742    289.46652    289.46652    43891.909    43891.909   -584.15605   -584.15605 
Loop time of 112.115 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.771 ns/day, 31.143 hours/ns, 8.919 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    | 111.12     | 111.12     | 111.12     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19951    | 0.19951    | 0.19951    |   0.0 |  0.18
Output  | 0.00017863 | 0.00017863 | 0.00017863 |   0.0 |  0.00
Modify  | 0.69359    | 0.69359    | 0.69359    |   0.0 |  0.62
Other   |            | 0.1033     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8302.00 ave        8302 max        8302 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:      966134.0 ave      966134 max      966134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966134
Ave neighs/atom = 241.53350
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.397572409571, Press = 0.59871145354705
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   30000   -17242.114   -17242.114   -17391.742   -17391.742    289.46652    289.46652    43891.909    43891.909   -584.15605   -584.15605 
   31000   -17237.231   -17237.231   -17388.561   -17388.561    292.75829    292.75829    43906.581    43906.581   -889.76673   -889.76673 
Loop time of 111.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.778 ns/day, 30.838 hours/ns, 9.008 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    | 110.03     | 110.03     | 110.03     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19719    | 0.19719    | 0.19719    |   0.0 |  0.18
Output  | 0.00017607 | 0.00017607 | 0.00017607 |   0.0 |  0.00
Modify  | 0.68688    | 0.68688    | 0.68688    |   0.0 |  0.62
Other   |            | 0.1022     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8310.00 ave        8310 max        8310 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:      966856.0 ave      966856 max      966856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966856
Ave neighs/atom = 241.71400
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.415100553824, Press = 0.620907938422244
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17237.231   -17237.231   -17388.561   -17388.561    292.75829    292.75829    43906.581    43906.581   -889.76673   -889.76673 
   32000   -17243.093   -17243.093   -17393.348   -17393.348    290.67855    290.67855    43883.879    43883.879   -339.56476   -339.56476 
Loop time of 110.933 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.779 ns/day, 30.815 hours/ns, 9.014 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    | 109.95     | 109.95     | 109.95     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19684    | 0.19684    | 0.19684    |   0.0 |  0.18
Output  | 0.00017552 | 0.00017552 | 0.00017552 |   0.0 |  0.00
Modify  | 0.68391    | 0.68391    | 0.68391    |   0.0 |  0.62
Other   |            | 0.1028     |            |       |  0.09

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:      966622.0 ave      966622 max      966622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966622
Ave neighs/atom = 241.65550
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.412656441154, Press = 1.43103714287424
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   32000   -17243.093   -17243.093   -17393.348   -17393.348    290.67855    290.67855    43883.879    43883.879   -339.56476   -339.56476 
   33000   -17236.368   -17236.368   -17389.334   -17389.334    295.92322    295.92322    43841.463    43841.463    1605.3645    1605.3645 
Loop time of 112.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.298 hours/ns, 8.875 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.67     | 111.67     | 111.67     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20023    | 0.20023    | 0.20023    |   0.0 |  0.18
Output  | 0.00016924 | 0.00016924 | 0.00016924 |   0.0 |  0.00
Modify  | 0.69729    | 0.69729    | 0.69729    |   0.0 |  0.62
Other   |            | 0.1034     |            |       |  0.09

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:      967242.0 ave      967242 max      967242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967242
Ave neighs/atom = 241.81050
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.41055378625, Press = 1.93340823515544
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17236.368   -17236.368   -17389.334   -17389.334    295.92322    295.92322    43841.463    43841.463    1605.3645    1605.3645 
   34000   -17240.665   -17240.665     -17391.2     -17391.2    291.22058    291.22058      43783.6      43783.6     3641.551     3641.551 
Loop time of 111.692 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.774 ns/day, 31.026 hours/ns, 8.953 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    | 110.7      | 110.7      | 110.7      |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19778    | 0.19778    | 0.19778    |   0.0 |  0.18
Output  | 0.0002306  | 0.0002306  | 0.0002306  |   0.0 |  0.00
Modify  | 0.68711    | 0.68711    | 0.68711    |   0.0 |  0.62
Other   |            | 0.1032     |            |       |  0.09

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:      967874.0 ave      967874 max      967874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967874
Ave neighs/atom = 241.96850
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.452395269248, Press = -0.158780674600792
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   34000   -17240.665   -17240.665     -17391.2     -17391.2    291.22058    291.22058      43783.6      43783.6     3641.551     3641.551 
   35000   -17238.201   -17238.201   -17391.706   -17391.706    296.96612    296.96612    43858.283    43858.283    944.92901    944.92901 
Loop time of 113.546 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.761 ns/day, 31.540 hours/ns, 8.807 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    | 112.55     | 112.55     | 112.55     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19904    | 0.19904    | 0.19904    |   0.0 |  0.18
Output  | 0.00017868 | 0.00017868 | 0.00017868 |   0.0 |  0.00
Modify  | 0.6949     | 0.6949     | 0.6949     |   0.0 |  0.61
Other   |            | 0.1027     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8327.00 ave        8327 max        8327 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:      969364.0 ave      969364 max      969364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 969364
Ave neighs/atom = 242.34100
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.442399503572, Press = -0.838336938524252
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   35000   -17238.201   -17238.201   -17391.706   -17391.706    296.96612    296.96612    43858.283    43858.283    944.92901    944.92901 
   36000   -17243.689   -17243.689   -17394.889   -17394.889    292.50695    292.50695    43873.031    43873.031    76.574805    76.574805 
Loop time of 112.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.254 hours/ns, 8.888 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    | 111.52     | 111.52     | 111.52     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19814    | 0.19814    | 0.19814    |   0.0 |  0.18
Output  | 0.00017754 | 0.00017754 | 0.00017754 |   0.0 |  0.00
Modify  | 0.69395    | 0.69395    | 0.69395    |   0.0 |  0.62
Other   |            | 0.1034     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8311.00 ave        8311 max        8311 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:      967450.0 ave      967450 max      967450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967450
Ave neighs/atom = 241.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.400581871275, Press = -0.447694183090532
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17243.689   -17243.689   -17394.889   -17394.889    292.50695    292.50695    43873.031    43873.031    76.574805    76.574805 
   37000   -17240.517   -17240.517   -17391.826   -17391.826     292.7165     292.7165    43894.372    43894.372   -695.92368   -695.92368 
Loop time of 112.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.198 hours/ns, 8.904 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    | 111.32     | 111.32     | 111.32     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19865    | 0.19865    | 0.19865    |   0.0 |  0.18
Output  | 0.00022701 | 0.00022701 | 0.00022701 |   0.0 |  0.00
Modify  | 0.68882    | 0.68882    | 0.68882    |   0.0 |  0.61
Other   |            | 0.1032     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8276.00 ave        8276 max        8276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      967682.0 ave      967682 max      967682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967682
Ave neighs/atom = 241.92050
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.424655677645, Press = 0.119604647350298
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17240.517   -17240.517   -17391.826   -17391.826     292.7165     292.7165    43894.372    43894.372   -695.92368   -695.92368 
   38000   -17237.432   -17237.432   -17389.136   -17389.136    293.48159    293.48159    43941.598    43941.598   -2097.5788   -2097.5788 
Loop time of 112.14 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.150 hours/ns, 8.917 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    | 111.15     | 111.15     | 111.15     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19855    | 0.19855    | 0.19855    |   0.0 |  0.18
Output  | 0.00017549 | 0.00017549 | 0.00017549 |   0.0 |  0.00
Modify  | 0.69248    | 0.69248    | 0.69248    |   0.0 |  0.62
Other   |            | 0.1029     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8281.00 ave        8281 max        8281 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      966788.0 ave      966788 max      966788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966788
Ave neighs/atom = 241.69700
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.448613473531, Press = 0.300520720034609
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17237.432   -17237.432   -17389.136   -17389.136    293.48159    293.48159    43941.598    43941.598   -2097.5788   -2097.5788 
   39000   -17241.082   -17241.082   -17392.917   -17392.917    293.73635    293.73635    43917.382    43917.382   -1532.1936   -1532.1936 
Loop time of 112.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.189 hours/ns, 8.906 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    | 111.28     | 111.28     | 111.28     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20002    | 0.20002    | 0.20002    |   0.0 |  0.18
Output  | 0.00017703 | 0.00017703 | 0.00017703 |   0.0 |  0.00
Modify  | 0.69615    | 0.69615    | 0.69615    |   0.0 |  0.62
Other   |            | 0.1036     |            |       |  0.09

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:      965458.0 ave      965458 max      965458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 965458
Ave neighs/atom = 241.36450
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.442777551714, Press = 2.79464398936623
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.006 | 7.006 | 7.006 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17241.082   -17241.082   -17392.917   -17392.917    293.73635    293.73635    43917.382    43917.382   -1532.1936   -1532.1936 
   40000   -17238.707   -17238.707   -17390.762   -17390.762    294.16151    294.16151    43849.665    43849.665    1213.9066    1213.9066 
Loop time of 111.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.774 ns/day, 31.003 hours/ns, 8.960 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    | 110.62     | 110.62     | 110.62     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19782    | 0.19782    | 0.19782    |   0.0 |  0.18
Output  | 0.00022677 | 0.00022677 | 0.00022677 |   0.0 |  0.00
Modify  | 0.68862    | 0.68862    | 0.68862    |   0.0 |  0.62
Other   |            | 0.1027     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8297.00 ave        8297 max        8297 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:      966374.0 ave      966374 max      966374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966374
Ave neighs/atom = 241.59350
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.499312333497, Press = 1.63592713649268
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   40000   -17238.707   -17238.707   -17390.762   -17390.762    294.16151    294.16151    43849.665    43849.665    1213.9066    1213.9066 
   41000   -17238.492   -17238.492   -17390.252   -17390.252    293.58961    293.58961    43841.238    43841.238     1520.496     1520.496 
Loop time of 112.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.233 hours/ns, 8.894 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    | 111.44     | 111.44     | 111.44     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19924    | 0.19924    | 0.19924    |   0.0 |  0.18
Output  | 0.00022791 | 0.00022791 | 0.00022791 |   0.0 |  0.00
Modify  | 0.69534    | 0.69534    | 0.69534    |   0.0 |  0.62
Other   |            | 0.1036     |            |       |  0.09

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:      967534.0 ave      967534 max      967534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967534
Ave neighs/atom = 241.88350
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.492045071249, Press = 0.131011250276783
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17238.492   -17238.492   -17390.252   -17390.252    293.58961    293.58961    43841.238    43841.238     1520.496     1520.496 
   42000   -17238.579   -17238.579   -17391.593   -17391.593    296.01522    296.01522    43884.937    43884.937   -252.50673   -252.50673 
Loop time of 110.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.780 ns/day, 30.781 hours/ns, 9.024 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    | 109.83     | 109.83     | 109.83     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19732    | 0.19732    | 0.19732    |   0.0 |  0.18
Output  | 0.00017804 | 0.00017804 | 0.00017804 |   0.0 |  0.00
Modify  | 0.68509    | 0.68509    | 0.68509    |   0.0 |  0.62
Other   |            | 0.1027     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8286.00 ave        8286 max        8286 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:      968154.0 ave      968154 max      968154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 968154
Ave neighs/atom = 242.03850
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.519097869994, Press = -0.552150826538916
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   42000   -17238.579   -17238.579   -17391.593   -17391.593    296.01522    296.01522    43884.937    43884.937   -252.50673   -252.50673 
   43000   -17243.379   -17243.379   -17392.387   -17392.387    288.26499    288.26499    43902.579    43902.579   -1045.9321   -1045.9321 
Loop time of 113.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.763 ns/day, 31.434 hours/ns, 8.837 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    | 112.16     | 112.16     | 112.16     |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1999     | 0.1999     | 0.1999     |   0.0 |  0.18
Output  | 0.00017709 | 0.00017709 | 0.00017709 |   0.0 |  0.00
Modify  | 0.70007    | 0.70007    | 0.70007    |   0.0 |  0.62
Other   |            | 0.1028     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8293.00 ave        8293 max        8293 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:      967366.0 ave      967366 max      967366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967366
Ave neighs/atom = 241.84150
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.477168673754, Press = -0.0763609681962794
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17243.379   -17243.379   -17392.387   -17392.387    288.26499    288.26499    43902.579    43902.579   -1045.9321   -1045.9321 
   44000   -17239.959   -17239.959   -17392.075   -17392.075    294.27901    294.27901    43924.486    43924.486   -1711.5953   -1711.5953 
Loop time of 114.015 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.671 hours/ns, 8.771 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    | 113.01     | 113.01     | 113.01     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19898    | 0.19898    | 0.19898    |   0.0 |  0.17
Output  | 0.00017729 | 0.00017729 | 0.00017729 |   0.0 |  0.00
Modify  | 0.69842    | 0.69842    | 0.69842    |   0.0 |  0.61
Other   |            | 0.1034     |            |       |  0.09

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:      966674.0 ave      966674 max      966674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966674
Ave neighs/atom = 241.66850
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.455295471918, Press = 0.917274250241787
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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   -17239.959   -17239.959   -17392.075   -17392.075    294.27901    294.27901    43924.486    43924.486   -1711.5953   -1711.5953 
   45000   -17243.462   -17243.462   -17394.917   -17394.917    292.99891    292.99891    43877.743    43877.743   -88.663292   -88.663292 
Loop time of 112.09 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.771 ns/day, 31.136 hours/ns, 8.921 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    | 111.1      | 111.1      | 111.1      |   0.0 | 99.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19867    | 0.19867    | 0.19867    |   0.0 |  0.18
Output  | 0.00018937 | 0.00018937 | 0.00018937 |   0.0 |  0.00
Modify  | 0.69185    | 0.69185    | 0.69185    |   0.0 |  0.62
Other   |            | 0.1032     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8276.00 ave        8276 max        8276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      966138.0 ave      966138 max      966138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 966138
Ave neighs/atom = 241.53450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.388934114359, Press = 2.5040754210492
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      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 
   45000   -17243.462   -17243.462   -17394.917   -17394.917    292.99891    292.99891    43877.743    43877.743   -88.663292   -88.663292 
   46000   -17237.565   -17237.565   -17391.456   -17391.456    297.71278    297.71278    43844.371    43844.371    1343.8492    1343.8492 
Loop time of 113.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.760 ns/day, 31.574 hours/ns, 8.798 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    | 112.67     | 112.67     | 112.67     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19976    | 0.19976    | 0.19976    |   0.0 |  0.18
Output  | 0.00022182 | 0.00022182 | 0.00022182 |   0.0 |  0.00
Modify  | 0.69558    | 0.69558    | 0.69558    |   0.0 |  0.61
Other   |            | 0.1033     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8328.00 ave        8328 max        8328 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:      967388.0 ave      967388 max      967388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967388
Ave neighs/atom = 241.84700
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.368451299958, Press = 1.32584307672293
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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17237.565   -17237.565   -17391.456   -17391.456    297.71278    297.71278    43844.371    43844.371    1343.8492    1343.8492 
   47000   -17242.704   -17242.704   -17393.828   -17393.828    292.35827    292.35827    43848.636    43848.636    1022.4211    1022.4211 
Loop time of 114.8 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.889 hours/ns, 8.711 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.78     | 113.78     | 113.78     |   0.0 | 99.12
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20209    | 0.20209    | 0.20209    |   0.0 |  0.18
Output  | 0.00017862 | 0.00017862 | 0.00017862 |   0.0 |  0.00
Modify  | 0.7094     | 0.7094     | 0.7094     |   0.0 |  0.62
Other   |            | 0.1037     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8286.00 ave        8286 max        8286 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:      967776.0 ave      967776 max      967776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 967776
Ave neighs/atom = 241.94400
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
43878.6094571665

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0