# 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.520024351775646*${_u_distance}
variable latticeconst_converted equal 3.520024351775646*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52002435177565
Lattice spacing in x,y,z = 3.5200244 3.5200244 3.5200244
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.200244 35.200244 35.200244)
  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.200244 35.200244 35.200244)
  create_atoms CPU = 0.002 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_SamolyukBelandStocks_2016_NiPd__MO_532072268679_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 43615.1131909852    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43615.1131909852/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43615.1131909852/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43615.1131909852/(1*1*${_u_distance})
variable      V0_metal equal 43615.1131909852/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43615.1131909852*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43615.1131909852 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 273.15*${_u_temperature}
variable temp_converted equal 273.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_532072268679_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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
       0   -17655.276   -17655.276   -17796.471   -17796.471       273.15       273.15    43615.113    43615.113    3457.8125    3457.8125 
    1000   -17503.377   -17503.377   -17645.471   -17645.471    274.89148    274.89148    43887.305    43887.305     637.0259     637.0259 
Loop time of 36.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.395 ns/day, 10.019 hours/ns, 27.725 timesteps/s
98.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 35.637     | 35.637     | 35.637     |   0.0 | 98.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067764   | 0.067764   | 0.067764   |   0.0 |  0.19
Output  | 0.00031025 | 0.00031025 | 0.00031025 |   0.0 |  0.00
Modify  | 0.31144    | 0.31144    | 0.31144    |   0.0 |  0.86
Other   |            | 0.05197    |            |       |  0.14

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:      896000.0 ave      896000 max      896000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 896000
Ave neighs/atom = 224.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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17503.377   -17503.377   -17645.471   -17645.471    274.89148    274.89148    43887.305    43887.305     637.0259     637.0259 
    2000   -17513.942   -17513.942   -17647.047   -17647.047    257.50154    257.50154    43922.149    43922.149   -1248.7523   -1248.7523 
Loop time of 38.9556 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.218 ns/day, 10.821 hours/ns, 25.670 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.496     | 38.496     | 38.496     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073644   | 0.073644   | 0.073644   |   0.0 |  0.19
Output  | 0.00024865 | 0.00024865 | 0.00024865 |   0.0 |  0.00
Modify  | 0.33184    | 0.33184    | 0.33184    |   0.0 |  0.85
Other   |            | 0.05366    |            |       |  0.14

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:      889292.0 ave      889292 max      889292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889292
Ave neighs/atom = 222.32300
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17513.942   -17513.942   -17647.047   -17647.047    257.50154    257.50154    43922.149    43922.149   -1248.7523   -1248.7523 
    3000   -17510.464   -17510.464   -17655.023   -17655.023    279.65924    279.65924    43918.603    43918.603   -1108.4841   -1108.4841 
Loop time of 64.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.330 ns/day, 18.042 hours/ns, 15.396 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    | 64.232     | 64.232     | 64.232     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11983    | 0.11983    | 0.11983    |   0.0 |  0.18
Output  | 0.00041282 | 0.00041282 | 0.00041282 |   0.0 |  0.00
Modify  | 0.52002    | 0.52002    | 0.52002    |   0.0 |  0.80
Other   |            | 0.07843    |            |       |  0.12

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:      889198.0 ave      889198 max      889198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889198
Ave neighs/atom = 222.29950
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17510.464   -17510.464   -17655.023   -17655.023    279.65924    279.65924    43918.603    43918.603   -1108.4841   -1108.4841 
    4000   -17509.837   -17509.837   -17653.188   -17653.188    277.32277    277.32277     43879.37     43879.37    600.21556    600.21556 
Loop time of 71.7986 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.203 ns/day, 19.944 hours/ns, 13.928 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    | 71.017     | 71.017     | 71.017     |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13085    | 0.13085    | 0.13085    |   0.0 |  0.18
Output  | 0.00022078 | 0.00022078 | 0.00022078 |   0.0 |  0.00
Modify  | 0.5679     | 0.5679     | 0.5679     |   0.0 |  0.79
Other   |            | 0.08279    |            |       |  0.12

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:      890062.0 ave      890062 max      890062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890062
Ave neighs/atom = 222.51550
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17509.837   -17509.837   -17653.188   -17653.188    277.32277    277.32277     43879.37     43879.37    600.21556    600.21556 
    5000   -17513.429   -17513.429    -17653.96    -17653.96    271.86663    271.86663    43885.969    43885.969    6.8261856    6.8261856 
Loop time of 71.7462 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.930 hours/ns, 13.938 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    | 70.966     | 70.966     | 70.966     |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13107    | 0.13107    | 0.13107    |   0.0 |  0.18
Output  | 0.0001722  | 0.0001722  | 0.0001722  |   0.0 |  0.00
Modify  | 0.56785    | 0.56785    | 0.56785    |   0.0 |  0.79
Other   |            | 0.08154    |            |       |  0.11

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:      889496.0 ave      889496 max      889496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889496
Ave neighs/atom = 222.37400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.618434975637, Press = 390.291513776118
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17513.429   -17513.429    -17653.96    -17653.96    271.86663    271.86663    43885.969    43885.969    6.8261856    6.8261856 
    6000   -17508.727   -17508.727   -17651.638   -17651.638    276.47076    276.47076    43932.677    43932.677   -1526.9781   -1526.9781 
Loop time of 71.7525 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.204 ns/day, 19.931 hours/ns, 13.937 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    | 70.955     | 70.955     | 70.955     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13054    | 0.13054    | 0.13054    |   0.0 |  0.18
Output  | 0.00017593 | 0.00017593 | 0.00017593 |   0.0 |  0.00
Modify  | 0.58422    | 0.58422    | 0.58422    |   0.0 |  0.81
Other   |            | 0.08215    |            |       |  0.11

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:      890092.0 ave      890092 max      890092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890092
Ave neighs/atom = 222.52300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.792223767734, Press = 33.8513824740987
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17508.727   -17508.727   -17651.638   -17651.638    276.47076    276.47076    43932.677    43932.677   -1526.9781   -1526.9781 
    7000   -17514.418   -17514.418    -17654.84    -17654.84    271.65677    271.65677    43933.254    43933.254   -1899.9984   -1899.9984 
Loop time of 71.7166 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.205 ns/day, 19.921 hours/ns, 13.944 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    | 70.921     | 70.921     | 70.921     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13017    | 0.13017    | 0.13017    |   0.0 |  0.18
Output  | 0.00017195 | 0.00017195 | 0.00017195 |   0.0 |  0.00
Modify  | 0.58315    | 0.58315    | 0.58315    |   0.0 |  0.81
Other   |            | 0.08189    |            |       |  0.11

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:      889116.0 ave      889116 max      889116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889116
Ave neighs/atom = 222.27900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.019154269466, Press = -12.1132408560686
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17514.418   -17514.418    -17654.84    -17654.84    271.65677    271.65677    43933.254    43933.254   -1899.9984   -1899.9984 
    8000   -17510.775   -17510.775   -17651.464   -17651.464     272.1733     272.1733    43872.544    43872.544    832.49124    832.49124 
Loop time of 71.2383 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.213 ns/day, 19.788 hours/ns, 14.037 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    | 70.449     | 70.449     | 70.449     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12943    | 0.12943    | 0.12943    |   0.0 |  0.18
Output  | 0.00017045 | 0.00017045 | 0.00017045 |   0.0 |  0.00
Modify  | 0.57805    | 0.57805    | 0.57805    |   0.0 |  0.81
Other   |            | 0.08124    |            |       |  0.11

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:      889188.0 ave      889188 max      889188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889188
Ave neighs/atom = 222.29700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.979467159135, Press = -5.87320863590758
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17510.775   -17510.775   -17651.464   -17651.464     272.1733     272.1733    43872.544    43872.544    832.49124    832.49124 
    9000   -17515.921   -17515.921   -17656.258   -17656.258    271.49257    271.49257    43857.695    43857.695    1132.3868    1132.3868 
Loop time of 69.2303 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.231 hours/ns, 14.445 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    | 68.463     | 68.463     | 68.463     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12631    | 0.12631    | 0.12631    |   0.0 |  0.18
Output  | 0.00018933 | 0.00018933 | 0.00018933 |   0.0 |  0.00
Modify  | 0.5643     | 0.5643     | 0.5643     |   0.0 |  0.82
Other   |            | 0.07673    |            |       |  0.11

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:      889622.0 ave      889622 max      889622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889622
Ave neighs/atom = 222.40550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.701940484068, Press = 7.5723890330635
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17515.921   -17515.921   -17656.258   -17656.258    271.49257    271.49257    43857.695    43857.695    1132.3868    1132.3868 
   10000   -17508.938   -17508.938   -17651.791   -17651.791    276.35835    276.35835    43893.538    43893.538   -53.579218   -53.579218 
Loop time of 69.2754 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.247 ns/day, 19.243 hours/ns, 14.435 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    | 68.508     | 68.508     | 68.508     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12672    | 0.12672    | 0.12672    |   0.0 |  0.18
Output  | 0.00017718 | 0.00017718 | 0.00017718 |   0.0 |  0.00
Modify  | 0.56473    | 0.56473    | 0.56473    |   0.0 |  0.82
Other   |            | 0.07624    |            |       |  0.11

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:      890116.0 ave      890116 max      890116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890116
Ave neighs/atom = 222.52900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.582550294769, Press = 5.37975651469249
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17508.938   -17508.938   -17651.791   -17651.791    276.35835    276.35835    43893.538    43893.538   -53.579218   -53.579218 
   11000   -17514.045   -17514.045   -17653.283   -17653.283    269.36557    269.36557     43888.81     43888.81   -8.9038923   -8.9038923 
Loop time of 69.2125 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.226 hours/ns, 14.448 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    | 68.443     | 68.443     | 68.443     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12694    | 0.12694    | 0.12694    |   0.0 |  0.18
Output  | 0.0001744  | 0.0001744  | 0.0001744  |   0.0 |  0.00
Modify  | 0.56556    | 0.56556    | 0.56556    |   0.0 |  0.82
Other   |            | 0.07649    |            |       |  0.11

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:      889592.0 ave      889592 max      889592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889592
Ave neighs/atom = 222.39800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.610269542801, Press = 1.76333732499175
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17514.045   -17514.045   -17653.283   -17653.283    269.36557    269.36557     43888.81     43888.81   -8.9038923   -8.9038923 
   12000   -17512.119   -17512.119   -17656.266   -17656.266    278.86091    278.86091    43881.569    43881.569    221.92615    221.92615 
Loop time of 69.3412 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.246 ns/day, 19.261 hours/ns, 14.421 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    | 68.575     | 68.575     | 68.575     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12584    | 0.12584    | 0.12584    |   0.0 |  0.18
Output  | 0.00017545 | 0.00017545 | 0.00017545 |   0.0 |  0.00
Modify  | 0.56412    | 0.56412    | 0.56412    |   0.0 |  0.81
Other   |            | 0.07592    |            |       |  0.11

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:      889642.0 ave      889642 max      889642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889642
Ave neighs/atom = 222.41050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.431349355547, Press = 2.91369825607695
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17512.119   -17512.119   -17656.266   -17656.266    278.86091    278.86091    43881.569    43881.569    221.92615    221.92615 
   13000   -17512.844   -17512.844   -17654.364   -17654.364    273.77919    273.77919    43885.824    43885.824    276.08607    276.08607 
Loop time of 69.2342 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.232 hours/ns, 14.444 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    | 68.469     | 68.469     | 68.469     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12633    | 0.12633    | 0.12633    |   0.0 |  0.18
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.5624     | 0.5624     | 0.5624     |   0.0 |  0.81
Other   |            | 0.07581    |            |       |  0.11

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:      890122.0 ave      890122 max      890122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890122
Ave neighs/atom = 222.53050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.4989174984, Press = 4.63839183189551
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17512.844   -17512.844   -17654.364   -17654.364    273.77919    273.77919    43885.824    43885.824    276.08607    276.08607 
   14000   -17508.518   -17508.518   -17654.949   -17654.949    283.28033    283.28033     43926.57     43926.57   -1311.0945   -1311.0945 
Loop time of 69.3721 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.245 ns/day, 19.270 hours/ns, 14.415 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    | 68.606     | 68.606     | 68.606     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1265     | 0.1265     | 0.1265     |   0.0 |  0.18
Output  | 0.00017346 | 0.00017346 | 0.00017346 |   0.0 |  0.00
Modify  | 0.56377    | 0.56377    | 0.56377    |   0.0 |  0.81
Other   |            | 0.07589    |            |       |  0.11

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:      889874.0 ave      889874 max      889874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889874
Ave neighs/atom = 222.46850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.519891322667, Press = 2.05287392981306
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17508.518   -17508.518   -17654.949   -17654.949    283.28033    283.28033     43926.57     43926.57   -1311.0945   -1311.0945 
   15000   -17512.215   -17512.215   -17655.095   -17655.095     276.4107     276.4107      43917.6      43917.6   -1078.9955   -1078.9955 
Loop time of 69.2662 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.247 ns/day, 19.241 hours/ns, 14.437 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    | 68.494     | 68.494     | 68.494     |   0.0 | 98.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12655    | 0.12655    | 0.12655    |   0.0 |  0.18
Output  | 0.00020353 | 0.00020353 | 0.00020353 |   0.0 |  0.00
Modify  | 0.5701     | 0.5701     | 0.5701     |   0.0 |  0.82
Other   |            | 0.07582    |            |       |  0.11

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:      889776.0 ave      889776 max      889776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889776
Ave neighs/atom = 222.44400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.553412213427, Press = -2.12301621116531
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17512.215   -17512.215   -17655.095   -17655.095     276.4107     276.4107      43917.6      43917.6   -1078.9955   -1078.9955 
   16000   -17508.588   -17508.588   -17650.604   -17650.604     274.7389     274.7389    43858.677    43858.677    1478.1435    1478.1435 
Loop time of 69.2513 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.236 hours/ns, 14.440 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    | 68.484     | 68.484     | 68.484     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12683    | 0.12683    | 0.12683    |   0.0 |  0.18
Output  | 0.00017494 | 0.00017494 | 0.00017494 |   0.0 |  0.00
Modify  | 0.564      | 0.564      | 0.564      |   0.0 |  0.81
Other   |            | 0.07613    |            |       |  0.11

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:      889934.0 ave      889934 max      889934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889934
Ave neighs/atom = 222.48350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.717815965032, Press = -2.60777232097768
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17508.588   -17508.588   -17650.604   -17650.604     274.7389     274.7389    43858.677    43858.677    1478.1435    1478.1435 
   17000   -17509.828   -17509.828    -17654.56    -17654.56    279.99402    279.99402    43841.876    43841.876    1980.1821    1980.1821 
Loop time of 69.2751 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.247 ns/day, 19.243 hours/ns, 14.435 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    | 68.508     | 68.508     | 68.508     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12669    | 0.12669    | 0.12669    |   0.0 |  0.18
Output  | 0.00019147 | 0.00019147 | 0.00019147 |   0.0 |  0.00
Modify  | 0.56375    | 0.56375    | 0.56375    |   0.0 |  0.81
Other   |            | 0.0761     |            |       |  0.11

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:      890116.0 ave      890116 max      890116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890116
Ave neighs/atom = 222.52900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.766558067404, Press = 3.52170749072351
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17509.828   -17509.828    -17654.56    -17654.56    279.99402    279.99402    43841.876    43841.876    1980.1821    1980.1821 
   18000   -17509.766   -17509.766   -17650.891   -17650.891    273.01613    273.01613    43893.275    43893.275     62.81976     62.81976 
Loop time of 69.2306 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.231 hours/ns, 14.444 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    | 68.465     | 68.465     | 68.465     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12633    | 0.12633    | 0.12633    |   0.0 |  0.18
Output  | 0.00016986 | 0.00016986 | 0.00016986 |   0.0 |  0.00
Modify  | 0.56315    | 0.56315    | 0.56315    |   0.0 |  0.81
Other   |            | 0.0763     |            |       |  0.11

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:      890660.0 ave      890660 max      890660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890660
Ave neighs/atom = 222.66500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.97421231441, Press = 2.76845620012943
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17509.766   -17509.766   -17650.891   -17650.891    273.01613    273.01613    43893.275    43893.275     62.81976     62.81976 
   19000   -17508.748   -17508.748    -17650.48    -17650.48    274.19026    274.19026    43903.739    43903.739   -306.83232   -306.83232 
Loop time of 69.3556 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.246 ns/day, 19.265 hours/ns, 14.418 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    | 68.59      | 68.59      | 68.59      |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12665    | 0.12665    | 0.12665    |   0.0 |  0.18
Output  | 0.00017446 | 0.00017446 | 0.00017446 |   0.0 |  0.00
Modify  | 0.56386    | 0.56386    | 0.56386    |   0.0 |  0.81
Other   |            | 0.07528    |            |       |  0.11

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:      889752.0 ave      889752 max      889752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889752
Ave neighs/atom = 222.43800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.000301426425, Press = 1.33259116567447
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17508.748   -17508.748    -17650.48    -17650.48    274.19026    274.19026    43903.739    43903.739   -306.83232   -306.83232 
   20000   -17512.789   -17512.789   -17654.205   -17654.205    273.57887    273.57887    43895.524    43895.524   -169.46389   -169.46389 
Loop time of 69.245 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.235 hours/ns, 14.441 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    | 68.479     | 68.479     | 68.479     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12644    | 0.12644    | 0.12644    |   0.0 |  0.18
Output  | 0.00017356 | 0.00017356 | 0.00017356 |   0.0 |  0.00
Modify  | 0.56308    | 0.56308    | 0.56308    |   0.0 |  0.81
Other   |            | 0.07602    |            |       |  0.11

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:      889468.0 ave      889468 max      889468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889468
Ave neighs/atom = 222.36700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.007217302799, Press = 0.874477215650277
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17512.789   -17512.789   -17654.205   -17654.205    273.57887    273.57887    43895.524    43895.524   -169.46389   -169.46389 
   21000   -17509.663   -17509.663   -17650.785   -17650.785    273.01024    273.01024    43886.515    43886.515    402.59736    402.59736 
Loop time of 69.2965 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.247 ns/day, 19.249 hours/ns, 14.431 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    | 68.532     | 68.532     | 68.532     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12597    | 0.12597    | 0.12597    |   0.0 |  0.18
Output  | 0.00017179 | 0.00017179 | 0.00017179 |   0.0 |  0.00
Modify  | 0.56294    | 0.56294    | 0.56294    |   0.0 |  0.81
Other   |            | 0.07564    |            |       |  0.11

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:      889830.0 ave      889830 max      889830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889830
Ave neighs/atom = 222.45750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.958995418111, Press = 0.963472985769876
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17509.663   -17509.663   -17650.785   -17650.785    273.01024    273.01024    43886.515    43886.515    402.59736    402.59736 
   22000   -17515.636   -17515.636   -17654.694   -17654.694    269.01697    269.01697     43896.77     43896.77   -274.31101   -274.31101 
Loop time of 68.2939 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.265 ns/day, 18.971 hours/ns, 14.643 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    | 67.536     | 67.536     | 67.536     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12552    | 0.12552    | 0.12552    |   0.0 |  0.18
Output  | 0.00017231 | 0.00017231 | 0.00017231 |   0.0 |  0.00
Modify  | 0.55665    | 0.55665    | 0.55665    |   0.0 |  0.82
Other   |            | 0.07515    |            |       |  0.11

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:      889636.0 ave      889636 max      889636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889636
Ave neighs/atom = 222.40900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.882870907659, Press = 1.49502060833414
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17515.636   -17515.636   -17654.694   -17654.694    269.01697    269.01697     43896.77     43896.77   -274.31101   -274.31101 
   23000   -17511.956   -17511.956   -17653.576   -17653.576    273.97341    273.97341    43916.192    43916.192   -974.98933   -974.98933 
Loop time of 69.2397 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.233 hours/ns, 14.443 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    | 68.475     | 68.475     | 68.475     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12698    | 0.12698    | 0.12698    |   0.0 |  0.18
Output  | 0.00017293 | 0.00017293 | 0.00017293 |   0.0 |  0.00
Modify  | 0.56265    | 0.56265    | 0.56265    |   0.0 |  0.81
Other   |            | 0.07515    |            |       |  0.11

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:      890004.0 ave      890004 max      890004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890004
Ave neighs/atom = 222.50100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.858532802336, Press = -0.376744368600761
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17511.956   -17511.956   -17653.576   -17653.576    273.97341    273.97341    43916.192    43916.192   -974.98933   -974.98933 
   24000   -17505.196   -17505.196   -17649.706   -17649.706    279.56455    279.56455    43881.044    43881.044    679.05818    679.05818 
Loop time of 69.2308 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.231 hours/ns, 14.444 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    | 68.468     | 68.468     | 68.468     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12609    | 0.12609    | 0.12609    |   0.0 |  0.18
Output  | 0.00017317 | 0.00017317 | 0.00017317 |   0.0 |  0.00
Modify  | 0.56162    | 0.56162    | 0.56162    |   0.0 |  0.81
Other   |            | 0.07494    |            |       |  0.11

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:      889610.0 ave      889610 max      889610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889610
Ave neighs/atom = 222.40250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.838223191172, Press = -1.19908682886014
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17505.196   -17505.196   -17649.706   -17649.706    279.56455    279.56455    43881.044    43881.044    679.05818    679.05818 
   25000    -17512.17    -17512.17    -17651.83    -17651.83    270.18036    270.18036    43834.663    43834.663    2280.0558    2280.0558 
Loop time of 69.2089 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.225 hours/ns, 14.449 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    | 68.446     | 68.446     | 68.446     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12574    | 0.12574    | 0.12574    |   0.0 |  0.18
Output  | 0.00012986 | 0.00012986 | 0.00012986 |   0.0 |  0.00
Modify  | 0.56236    | 0.56236    | 0.56236    |   0.0 |  0.81
Other   |            | 0.07511    |            |       |  0.11

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:      889806.0 ave      889806 max      889806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889806
Ave neighs/atom = 222.45150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857539537676, Press = 1.5473986553767
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -17512.17    -17512.17    -17651.83    -17651.83    270.18036    270.18036    43834.663    43834.663    2280.0558    2280.0558 
   26000   -17507.624   -17507.624   -17649.429   -17649.429    274.32985    274.32985    43888.089    43888.089    319.24194    319.24194 
Loop time of 69.3702 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.245 ns/day, 19.269 hours/ns, 14.415 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    | 68.606     | 68.606     | 68.606     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12615    | 0.12615    | 0.12615    |   0.0 |  0.18
Output  | 0.00016788 | 0.00016788 | 0.00016788 |   0.0 |  0.00
Modify  | 0.56232    | 0.56232    | 0.56232    |   0.0 |  0.81
Other   |            | 0.07558    |            |       |  0.11

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:      890346.0 ave      890346 max      890346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890346
Ave neighs/atom = 222.58650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.901716117396, Press = 3.19817795279099
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17507.624   -17507.624   -17649.429   -17649.429    274.32985    274.32985    43888.089    43888.089    319.24194    319.24194 
   27000   -17514.484   -17514.484   -17652.557   -17652.557    267.11302    267.11302    43917.175    43917.175   -1102.9483   -1102.9483 
Loop time of 69.319 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.246 ns/day, 19.255 hours/ns, 14.426 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    | 68.557     | 68.557     | 68.557     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.126      | 0.126      | 0.126      |   0.0 |  0.18
Output  | 0.00017426 | 0.00017426 | 0.00017426 |   0.0 |  0.00
Modify  | 0.56134    | 0.56134    | 0.56134    |   0.0 |  0.81
Other   |            | 0.07491    |            |       |  0.11

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:      889480.0 ave      889480 max      889480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889480
Ave neighs/atom = 222.37000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.886742056609, Press = 0.941244312768733
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17514.484   -17514.484   -17652.557   -17652.557    267.11302    267.11302    43917.175    43917.175   -1102.9483   -1102.9483 
   28000   -17509.544   -17509.544   -17654.239   -17654.239    279.92214    279.92214    43905.881    43905.881   -577.79371   -577.79371 
Loop time of 69.2953 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.247 ns/day, 19.249 hours/ns, 14.431 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    | 68.535     | 68.535     | 68.535     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12578    | 0.12578    | 0.12578    |   0.0 |  0.18
Output  | 0.00017451 | 0.00017451 | 0.00017451 |   0.0 |  0.00
Modify  | 0.56005    | 0.56005    | 0.56005    |   0.0 |  0.81
Other   |            | 0.07441    |            |       |  0.11

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:      889478.0 ave      889478 max      889478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889478
Ave neighs/atom = 222.36950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.893350231586, Press = -0.0701776621256585
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17509.544   -17509.544   -17654.239   -17654.239    279.92214    279.92214    43905.881    43905.881   -577.79371   -577.79371 
   29000   -17507.787   -17507.787   -17653.115   -17653.115    281.14577    281.14577    43893.386    43893.386     1.705695     1.705695 
Loop time of 69.232 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.231 hours/ns, 14.444 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    | 68.471     | 68.471     | 68.471     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12579    | 0.12579    | 0.12579    |   0.0 |  0.18
Output  | 0.00016827 | 0.00016827 | 0.00016827 |   0.0 |  0.00
Modify  | 0.56042    | 0.56042    | 0.56042    |   0.0 |  0.81
Other   |            | 0.07452    |            |       |  0.11

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:      889596.0 ave      889596 max      889596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889596
Ave neighs/atom = 222.39900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.875701996103, Press = -0.0710987199086798
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17507.787   -17507.787   -17653.115   -17653.115    281.14577    281.14577    43893.386    43893.386     1.705695     1.705695 
   30000   -17507.638   -17507.638    -17652.61    -17652.61    280.45649    280.45649    43861.963    43861.963    1342.9381    1342.9381 
Loop time of 56.5388 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.528 ns/day, 15.705 hours/ns, 17.687 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    | 55.895     | 55.895     | 55.895     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10398    | 0.10398    | 0.10398    |   0.0 |  0.18
Output  | 0.00010284 | 0.00010284 | 0.00010284 |   0.0 |  0.00
Modify  | 0.47194    | 0.47194    | 0.47194    |   0.0 |  0.83
Other   |            | 0.06794    |            |       |  0.12

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:      890012.0 ave      890012 max      890012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890012
Ave neighs/atom = 222.50300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.905966283947, Press = 0.215257220275094
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17507.638   -17507.638    -17652.61    -17652.61    280.45649    280.45649    43861.963    43861.963    1342.9381    1342.9381 
   31000   -17511.035   -17511.035   -17649.795   -17649.795    268.44043    268.44043     43851.12     43851.12    1773.5357    1773.5357 
Loop time of 53.8125 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.606 ns/day, 14.948 hours/ns, 18.583 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    | 53.205     | 53.205     | 53.205     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099073   | 0.099073   | 0.099073   |   0.0 |  0.18
Output  | 0.00018335 | 0.00018335 | 0.00018335 |   0.0 |  0.00
Modify  | 0.44345    | 0.44345    | 0.44345    |   0.0 |  0.82
Other   |            | 0.06453    |            |       |  0.12

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:      890086.0 ave      890086 max      890086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890086
Ave neighs/atom = 222.52150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.924154291157, Press = 3.44231762905764
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17511.035   -17511.035   -17649.795   -17649.795    268.44043    268.44043     43851.12     43851.12    1773.5357    1773.5357 
   32000   -17510.862   -17510.862   -17650.952   -17650.952    271.01368    271.01368    43934.103    43934.103    -1557.054    -1557.054 
Loop time of 69.2637 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.247 ns/day, 19.240 hours/ns, 14.438 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    | 68.502     | 68.502     | 68.502     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12615    | 0.12615    | 0.12615    |   0.0 |  0.18
Output  | 0.00017776 | 0.00017776 | 0.00017776 |   0.0 |  0.00
Modify  | 0.56089    | 0.56089    | 0.56089    |   0.0 |  0.81
Other   |            | 0.07459    |            |       |  0.11

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:      890182.0 ave      890182 max      890182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890182
Ave neighs/atom = 222.54550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.013790536083, Press = 2.08047226107161
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17510.862   -17510.862   -17650.952   -17650.952    271.01368    271.01368    43934.103    43934.103    -1557.054    -1557.054 
   33000   -17507.025   -17507.025   -17648.426   -17648.426    273.54865    273.54865    43934.986    43934.986   -1469.9788   -1469.9788 
Loop time of 69.1614 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.211 hours/ns, 14.459 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    | 68.399     | 68.399     | 68.399     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12657    | 0.12657    | 0.12657    |   0.0 |  0.18
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.56079    | 0.56079    | 0.56079    |   0.0 |  0.81
Other   |            | 0.07475    |            |       |  0.11

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:      889204.0 ave      889204 max      889204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889204
Ave neighs/atom = 222.30100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.025233235507, Press = -0.257599810169542
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17507.025   -17507.025   -17648.426   -17648.426    273.54865    273.54865    43934.986    43934.986   -1469.9788   -1469.9788 
   34000   -17511.204   -17511.204   -17650.686   -17650.686    269.83664    269.83664    43885.188    43885.188    404.43109    404.43109 
Loop time of 69.1854 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.218 hours/ns, 14.454 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    | 68.427     | 68.427     | 68.427     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12553    | 0.12553    | 0.12553    |   0.0 |  0.18
Output  | 0.0001729  | 0.0001729  | 0.0001729  |   0.0 |  0.00
Modify  | 0.55885    | 0.55885    | 0.55885    |   0.0 |  0.81
Other   |            | 0.07388    |            |       |  0.11

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:      889136.0 ave      889136 max      889136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889136
Ave neighs/atom = 222.28400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.056388577384, Press = -0.628896174340384
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17511.204   -17511.204   -17650.686   -17650.686    269.83664    269.83664    43885.188    43885.188    404.43109    404.43109 
   35000    -17511.46    -17511.46   -17655.743   -17655.743    279.12487    279.12487    43864.996    43864.996    1060.7051    1060.7051 
Loop time of 63.3991 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.611 hours/ns, 15.773 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    | 62.703     | 62.703     | 62.703     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11524    | 0.11524    | 0.11524    |   0.0 |  0.18
Output  | 0.00014555 | 0.00014555 | 0.00014555 |   0.0 |  0.00
Modify  | 0.51307    | 0.51307    | 0.51307    |   0.0 |  0.81
Other   |            | 0.06763    |            |       |  0.11

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:      889920.0 ave      889920 max      889920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889920
Ave neighs/atom = 222.48000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.122671577813, Press = 0.316364602742326
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -17511.46    -17511.46   -17655.743   -17655.743    279.12487    279.12487    43864.996    43864.996    1060.7051    1060.7051 
   36000   -17509.072   -17509.072   -17650.815   -17650.815    274.21315    274.21315    43891.306    43891.306    124.66063    124.66063 
Loop time of 69.1947 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.221 hours/ns, 14.452 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    | 68.435     | 68.435     | 68.435     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12544    | 0.12544    | 0.12544    |   0.0 |  0.18
Output  | 0.00018277 | 0.00018277 | 0.00018277 |   0.0 |  0.00
Modify  | 0.56015    | 0.56015    | 0.56015    |   0.0 |  0.81
Other   |            | 0.07436    |            |       |  0.11

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:      890136.0 ave      890136 max      890136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890136
Ave neighs/atom = 222.53400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.11796739082, Press = 1.26883819448929
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17509.072   -17509.072   -17650.815   -17650.815    274.21315    274.21315    43891.306    43891.306    124.66063    124.66063 
   37000   -17513.345   -17513.345   -17652.692   -17652.692    269.57571    269.57571    43914.922    43914.922   -964.44845   -964.44845 
Loop time of 69.1449 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.250 ns/day, 19.207 hours/ns, 14.462 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    | 68.386     | 68.386     | 68.386     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12542    | 0.12542    | 0.12542    |   0.0 |  0.18
Output  | 0.00017067 | 0.00017067 | 0.00017067 |   0.0 |  0.00
Modify  | 0.55927    | 0.55927    | 0.55927    |   0.0 |  0.81
Other   |            | 0.07388    |            |       |  0.11

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:      889628.0 ave      889628 max      889628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889628
Ave neighs/atom = 222.40700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.05841731358, Press = 0.926523838151717
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17513.345   -17513.345   -17652.692   -17652.692    269.57571    269.57571    43914.922    43914.922   -964.44845   -964.44845 
   38000   -17511.632   -17511.632   -17651.195   -17651.195    269.99409    269.99409    43945.792    43945.792   -2127.4079   -2127.4079 
Loop time of 69.1862 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.218 hours/ns, 14.454 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    | 68.428     | 68.428     | 68.428     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12552    | 0.12552    | 0.12552    |   0.0 |  0.18
Output  | 0.00017426 | 0.00017426 | 0.00017426 |   0.0 |  0.00
Modify  | 0.55909    | 0.55909    | 0.55909    |   0.0 |  0.81
Other   |            | 0.07361    |            |       |  0.11

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:      889522.0 ave      889522 max      889522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889522
Ave neighs/atom = 222.38050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.051548242712, Press = -0.400902860929601
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17511.632   -17511.632   -17651.195   -17651.195    269.99409    269.99409    43945.792    43945.792   -2127.4079   -2127.4079 
   39000   -17510.568   -17510.568   -17652.668   -17652.668    274.90263    274.90263    43906.041    43906.041   -571.79009   -571.79009 
Loop time of 69.1213 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.250 ns/day, 19.200 hours/ns, 14.467 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    | 68.364     | 68.364     | 68.364     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12563    | 0.12563    | 0.12563    |   0.0 |  0.18
Output  | 0.00018289 | 0.00018289 | 0.00018289 |   0.0 |  0.00
Modify  | 0.55812    | 0.55812    | 0.55812    |   0.0 |  0.81
Other   |            | 0.07354    |            |       |  0.11

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:      888792.0 ave      888792 max      888792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 888792
Ave neighs/atom = 222.19800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.006474328285, Press = -1.69070152930775
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17510.568   -17510.568   -17652.668   -17652.668    274.90263    274.90263    43906.041    43906.041   -571.79009   -571.79009 
   40000   -17516.139   -17516.139   -17655.686   -17655.686    269.96388    269.96388    43850.463    43850.463    1404.7542    1404.7542 
Loop time of 69.2419 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.234 hours/ns, 14.442 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    | 68.481     | 68.481     | 68.481     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12651    | 0.12651    | 0.12651    |   0.0 |  0.18
Output  | 0.00017089 | 0.00017089 | 0.00017089 |   0.0 |  0.00
Modify  | 0.55969    | 0.55969    | 0.55969    |   0.0 |  0.81
Other   |            | 0.07406    |            |       |  0.11

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:      889518.0 ave      889518 max      889518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889518
Ave neighs/atom = 222.37950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.98683251479, Press = -0.207702094168558
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17516.139   -17516.139   -17655.686   -17655.686    269.96388    269.96388    43850.463    43850.463    1404.7542    1404.7542 
   41000   -17509.048   -17509.048   -17653.341   -17653.341    279.14309    279.14309    43874.898    43874.898    742.46107    742.46107 
Loop time of 69.1693 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.214 hours/ns, 14.457 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    | 68.41      | 68.41      | 68.41      |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12559    | 0.12559    | 0.12559    |   0.0 |  0.18
Output  | 0.00016885 | 0.00016885 | 0.00016885 |   0.0 |  0.00
Modify  | 0.55981    | 0.55981    | 0.55981    |   0.0 |  0.81
Other   |            | 0.07363    |            |       |  0.11

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:      890228.0 ave      890228 max      890228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890228
Ave neighs/atom = 222.55700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.961100543499, Press = 0.951114450309758
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17509.048   -17509.048   -17653.341   -17653.341    279.14309    279.14309    43874.898    43874.898    742.46107    742.46107 
   42000   -17509.749   -17509.749   -17651.751   -17651.751    274.71165    274.71165    43904.815    43904.815   -375.05886   -375.05886 
Loop time of 69.1935 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.220 hours/ns, 14.452 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    | 68.435     | 68.435     | 68.435     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12603    | 0.12603    | 0.12603    |   0.0 |  0.18
Output  | 0.00017556 | 0.00017556 | 0.00017556 |   0.0 |  0.00
Modify  | 0.55828    | 0.55828    | 0.55828    |   0.0 |  0.81
Other   |            | 0.07366    |            |       |  0.11

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:      890040.0 ave      890040 max      890040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890040
Ave neighs/atom = 222.51000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.955737007294, Press = 1.06539709694658
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17509.749   -17509.749   -17651.751   -17651.751    274.71165    274.71165    43904.815    43904.815   -375.05886   -375.05886 
   43000   -17513.703   -17513.703   -17652.634   -17652.634    268.77141    268.77141    43929.198    43929.198   -1476.9551   -1476.9551 
Loop time of 69.1472 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.250 ns/day, 19.208 hours/ns, 14.462 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    | 68.389     | 68.389     | 68.389     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12561    | 0.12561    | 0.12561    |   0.0 |  0.18
Output  | 0.00017819 | 0.00017819 | 0.00017819 |   0.0 |  0.00
Modify  | 0.55884    | 0.55884    | 0.55884    |   0.0 |  0.81
Other   |            | 0.07384    |            |       |  0.11

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:      889712.0 ave      889712 max      889712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889712
Ave neighs/atom = 222.42800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.964628419191, Press = 0.2185012482641
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17513.703   -17513.703   -17652.634   -17652.634    268.77141    268.77141    43929.198    43929.198   -1476.9551   -1476.9551 
   44000   -17510.906   -17510.906   -17650.733   -17650.733    270.50522    270.50522    43904.611    43904.611   -388.34397   -388.34397 
Loop time of 69.1999 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.222 hours/ns, 14.451 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    | 68.442     | 68.442     | 68.442     |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12586    | 0.12586    | 0.12586    |   0.0 |  0.18
Output  | 0.00017055 | 0.00017055 | 0.00017055 |   0.0 |  0.00
Modify  | 0.55806    | 0.55806    | 0.55806    |   0.0 |  0.81
Other   |            | 0.07329    |            |       |  0.11

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:      889156.0 ave      889156 max      889156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889156
Ave neighs/atom = 222.28900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.947061453564, Press = -1.14658106382337
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17510.906   -17510.906   -17650.733   -17650.733    270.50522    270.50522    43904.611    43904.611   -388.34397   -388.34397 
   45000   -17510.578   -17510.578   -17651.924   -17651.924    273.44424    273.44424    43826.705    43826.705    2641.8785    2641.8785 
Loop time of 60.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.427 ns/day, 16.824 hours/ns, 16.511 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    | 59.903     | 59.903     | 59.903     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11001    | 0.11001    | 0.11001    |   0.0 |  0.18
Output  | 0.00021897 | 0.00021897 | 0.00021897 |   0.0 |  0.00
Modify  | 0.48912    | 0.48912    | 0.48912    |   0.0 |  0.81
Other   |            | 0.06462    |            |       |  0.11

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:      889676.0 ave      889676 max      889676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889676
Ave neighs/atom = 222.41900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.907601162608, Press = -0.671060167881326
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17510.578   -17510.578   -17651.924   -17651.924    273.44424    273.44424    43826.705    43826.705    2641.8785    2641.8785 
   46000   -17514.404   -17514.404   -17655.808   -17655.808    273.55542    273.55542    43845.298    43845.298    1682.1697    1682.1697 
Loop time of 59.7236 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.447 ns/day, 16.590 hours/ns, 16.744 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    | 59.062     | 59.062     | 59.062     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10883    | 0.10883    | 0.10883    |   0.0 |  0.18
Output  | 0.00017166 | 0.00017166 | 0.00017166 |   0.0 |  0.00
Modify  | 0.48669    | 0.48669    | 0.48669    |   0.0 |  0.81
Other   |            | 0.06615    |            |       |  0.11

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:      890192.0 ave      890192 max      890192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890192
Ave neighs/atom = 222.54800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.894184874433, Press = 1.17622239538353
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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   -17514.404   -17514.404   -17655.808   -17655.808    273.55542    273.55542    43845.298    43845.298    1682.1697    1682.1697 
   47000   -17510.521   -17510.521   -17653.843   -17653.843    277.26604    277.26604    43903.249    43903.249    -451.0502    -451.0502 
Loop time of 69.1295 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.250 ns/day, 19.203 hours/ns, 14.466 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    | 68.371     | 68.371     | 68.371     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12566    | 0.12566    | 0.12566    |   0.0 |  0.18
Output  | 0.00017257 | 0.00017257 | 0.00017257 |   0.0 |  0.00
Modify  | 0.56       | 0.56       | 0.56       |   0.0 |  0.81
Other   |            | 0.07301    |            |       |  0.11

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:      890392.0 ave      890392 max      890392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890392
Ave neighs/atom = 222.59800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.896238955805, Press = 0.953619204622585
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17510.521   -17510.521   -17653.843   -17653.843    277.26604    277.26604    43903.249    43903.249    -451.0502    -451.0502 
   48000   -17512.886   -17512.886   -17651.957   -17651.957    269.04133    269.04133    43912.632    43912.632   -807.44445   -807.44445 
Loop time of 69.1732 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.215 hours/ns, 14.456 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    | 68.415     | 68.415     | 68.415     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12511    | 0.12511    | 0.12511    |   0.0 |  0.18
Output  | 0.00016853 | 0.00016853 | 0.00016853 |   0.0 |  0.00
Modify  | 0.55942    | 0.55942    | 0.55942    |   0.0 |  0.81
Other   |            | 0.07331    |            |       |  0.11

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:      889692.0 ave      889692 max      889692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889692
Ave neighs/atom = 222.42300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.893282273568, Press = 0.152018627479563
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17512.886   -17512.886   -17651.957   -17651.957    269.04133    269.04133    43912.632    43912.632   -807.44445   -807.44445 
   49000   -17512.304   -17512.304   -17651.205   -17651.205    268.71386    268.71386    43900.034    43900.034   -252.39126   -252.39126 
Loop time of 69.2478 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.235 hours/ns, 14.441 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    | 68.49      | 68.49      | 68.49      |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12576    | 0.12576    | 0.12576    |   0.0 |  0.18
Output  | 0.00017088 | 0.00017088 | 0.00017088 |   0.0 |  0.00
Modify  | 0.5591     | 0.5591     | 0.5591     |   0.0 |  0.81
Other   |            | 0.07308    |            |       |  0.11

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:      889644.0 ave      889644 max      889644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889644
Ave neighs/atom = 222.41100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.889516490197, Press = -0.191038365175151
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -17512.304   -17512.304   -17651.205   -17651.205    268.71386    268.71386    43900.034    43900.034   -252.39126   -252.39126 
   50000   -17509.099   -17509.099   -17651.478   -17651.478    275.44144    275.44144    43853.088    43853.088    1631.6914    1631.6914 
Loop time of 69.2174 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.227 hours/ns, 14.447 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    | 68.46      | 68.46      | 68.46      |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12557    | 0.12557    | 0.12557    |   0.0 |  0.18
Output  | 0.0001739  | 0.0001739  | 0.0001739  |   0.0 |  0.00
Modify  | 0.55844    | 0.55844    | 0.55844    |   0.0 |  0.81
Other   |            | 0.07309    |            |       |  0.11

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:      889604.0 ave      889604 max      889604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889604
Ave neighs/atom = 222.40100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.859380099042, Press = -0.4949369125793
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17509.099   -17509.099   -17651.478   -17651.478    275.44144    275.44144    43853.088    43853.088    1631.6914    1631.6914 
   51000   -17511.769   -17511.769   -17654.818   -17654.818    276.73973    276.73973    43828.045    43828.045    2438.8388    2438.8388 
Loop time of 69.1486 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.208 hours/ns, 14.462 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    | 68.391     | 68.391     | 68.391     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1258     | 0.1258     | 0.1258     |   0.0 |  0.18
Output  | 0.00018275 | 0.00018275 | 0.00018275 |   0.0 |  0.00
Modify  | 0.55874    | 0.55874    | 0.55874    |   0.0 |  0.81
Other   |            | 0.0732     |            |       |  0.11

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:      890088.0 ave      890088 max      890088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890088
Ave neighs/atom = 222.52200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857136645961, Press = 1.20655610117591
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   51000   -17511.769   -17511.769   -17654.818   -17654.818    276.73973    276.73973    43828.045    43828.045    2438.8388    2438.8388 
   52000   -17513.343   -17513.343   -17652.105   -17652.105    268.44475    268.44475    43895.324    43895.324   -62.482575   -62.482575 
Loop time of 69.2072 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.224 hours/ns, 14.449 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    | 68.449     | 68.449     | 68.449     |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12535    | 0.12535    | 0.12535    |   0.0 |  0.18
Output  | 0.00012925 | 0.00012925 | 0.00012925 |   0.0 |  0.00
Modify  | 0.55917    | 0.55917    | 0.55917    |   0.0 |  0.81
Other   |            | 0.07312    |            |       |  0.11

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:      890370.0 ave      890370 max      890370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890370
Ave neighs/atom = 222.59250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.869931341044, Press = 1.36539175408888
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   52000   -17513.343   -17513.343   -17652.105   -17652.105    268.44475    268.44475    43895.324    43895.324   -62.482575   -62.482575 
   53000   -17509.987   -17509.987   -17651.973   -17651.973    274.68232    274.68232    43929.277    43929.277   -1411.0389   -1411.0389 
Loop time of 69.1063 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.250 ns/day, 19.196 hours/ns, 14.470 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    | 68.348     | 68.348     | 68.348     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12541    | 0.12541    | 0.12541    |   0.0 |  0.18
Output  | 0.00018725 | 0.00018725 | 0.00018725 |   0.0 |  0.00
Modify  | 0.55898    | 0.55898    | 0.55898    |   0.0 |  0.81
Other   |            | 0.07327    |            |       |  0.11

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:      889730.0 ave      889730 max      889730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889730
Ave neighs/atom = 222.43250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.87240424876, Press = 0.441701526129059
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   53000   -17509.987   -17509.987   -17651.973   -17651.973    274.68232    274.68232    43929.277    43929.277   -1411.0389   -1411.0389 
   54000   -17513.848   -17513.848   -17656.935   -17656.935    276.81076    276.81076     43908.91     43908.91    -873.0924    -873.0924 
Loop time of 69.1719 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.214 hours/ns, 14.457 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    | 68.414     | 68.414     | 68.414     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1257     | 0.1257     | 0.1257     |   0.0 |  0.18
Output  | 0.000144   | 0.000144   | 0.000144   |   0.0 |  0.00
Modify  | 0.55859    | 0.55859    | 0.55859    |   0.0 |  0.81
Other   |            | 0.07303    |            |       |  0.11

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:      889104.0 ave      889104 max      889104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889104
Ave neighs/atom = 222.27600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.852055737247, Press = -0.258141738326157
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   54000   -17513.848   -17513.848   -17656.935   -17656.935    276.81076    276.81076     43908.91     43908.91    -873.0924    -873.0924 
   55000    -17510.78    -17510.78   -17651.316   -17651.316     271.8764     271.8764    43871.948    43871.948    807.34828    807.34828 
Loop time of 69.2289 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.230 hours/ns, 14.445 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    | 68.472     | 68.472     | 68.472     |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1253     | 0.1253     | 0.1253     |   0.0 |  0.18
Output  | 0.0001876  | 0.0001876  | 0.0001876  |   0.0 |  0.00
Modify  | 0.55876    | 0.55876    | 0.55876    |   0.0 |  0.81
Other   |            | 0.07304    |            |       |  0.11

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:      889900.0 ave      889900 max      889900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889900
Ave neighs/atom = 222.47500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.821314831999, Press = -0.343141147066634
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   55000    -17510.78    -17510.78   -17651.316   -17651.316     271.8764     271.8764    43871.948    43871.948    807.34828    807.34828 
   56000     -17515.2     -17515.2   -17657.737   -17657.737    275.74758    275.74758    43797.627    43797.627    3432.0478    3432.0478 
Loop time of 69.1463 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.250 ns/day, 19.207 hours/ns, 14.462 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    | 68.389     | 68.389     | 68.389     |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12529    | 0.12529    | 0.12529    |   0.0 |  0.18
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.55844    | 0.55844    | 0.55844    |   0.0 |  0.81
Other   |            | 0.07303    |            |       |  0.11

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:      889762.0 ave      889762 max      889762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889762
Ave neighs/atom = 222.44050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.816921622356, Press = 0.909865029716302
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   56000     -17515.2     -17515.2   -17657.737   -17657.737    275.74758    275.74758    43797.627    43797.627    3432.0478    3432.0478 
   57000   -17511.036   -17511.036   -17651.676   -17651.676    272.07757    272.07757    43883.322    43883.322    353.45522    353.45522 
Loop time of 69.2523 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.248 ns/day, 19.237 hours/ns, 14.440 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    | 68.495     | 68.495     | 68.495     |   0.0 | 98.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.125      | 0.125      | 0.125      |   0.0 |  0.18
Output  | 0.00012918 | 0.00012918 | 0.00012918 |   0.0 |  0.00
Modify  | 0.55885    | 0.55885    | 0.55885    |   0.0 |  0.81
Other   |            | 0.07324    |            |       |  0.11

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:      890712.0 ave      890712 max      890712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890712
Ave neighs/atom = 222.67800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.81276987087, Press = 1.62321834853588
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   57000   -17511.036   -17511.036   -17651.676   -17651.676    272.07757    272.07757    43883.322    43883.322    353.45522    353.45522 
   58000   -17510.383   -17510.383   -17652.944   -17652.944    275.79345    275.79345     43917.64     43917.64   -1029.2341   -1029.2341 
Loop time of 69.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.216 hours/ns, 14.456 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    | 68.419     | 68.419     | 68.419     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12531    | 0.12531    | 0.12531    |   0.0 |  0.18
Output  | 0.00017061 | 0.00017061 | 0.00017061 |   0.0 |  0.00
Modify  | 0.55956    | 0.55956    | 0.55956    |   0.0 |  0.81
Other   |            | 0.07328    |            |       |  0.11

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:      889736.0 ave      889736 max      889736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889736
Ave neighs/atom = 222.43400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.816731831468, Press = 0.819271273204686
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   58000   -17510.383   -17510.383   -17652.944   -17652.944    275.79345    275.79345     43917.64     43917.64   -1029.2341   -1029.2341 
   59000   -17514.315   -17514.315   -17652.222   -17652.222    266.79129    266.79129    43908.887    43908.887   -748.21372   -748.21372 
Loop time of 69.1504 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.249 ns/day, 19.208 hours/ns, 14.461 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    | 68.392     | 68.392     | 68.392     |   0.0 | 98.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12534    | 0.12534    | 0.12534    |   0.0 |  0.18
Output  | 0.00014182 | 0.00014182 | 0.00014182 |   0.0 |  0.00
Modify  | 0.55957    | 0.55957    | 0.55957    |   0.0 |  0.81
Other   |            | 0.07324    |            |       |  0.11

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:      889624.0 ave      889624 max      889624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889624
Ave neighs/atom = 222.40600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.823030514607, Press = 0.189046209795222
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   59000   -17514.315   -17514.315   -17652.222   -17652.222    266.79129    266.79129    43908.887    43908.887   -748.21372   -748.21372 
   60000   -17509.551   -17509.551   -17651.716   -17651.716    275.02827    275.02827    43888.888    43888.888     210.5599     210.5599 
Loop time of 52.9885 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.631 ns/day, 14.719 hours/ns, 18.872 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    | 52.379     | 52.379     | 52.379     |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098314   | 0.098314   | 0.098314   |   0.0 |  0.19
Output  | 0.00017601 | 0.00017601 | 0.00017601 |   0.0 |  0.00
Modify  | 0.4447     | 0.4447     | 0.4447     |   0.0 |  0.84
Other   |            | 0.06643    |            |       |  0.13

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:      889638.0 ave      889638 max      889638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889638
Ave neighs/atom = 222.40950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.803544309318, Press = -0.134895807919255
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   60000   -17509.551   -17509.551   -17651.716   -17651.716    275.02827    275.02827    43888.888    43888.888     210.5599     210.5599 
   61000   -17513.949   -17513.949   -17654.012   -17654.012    270.95963    270.95963     43813.66     43813.66    2911.7085    2911.7085 
Loop time of 70.1138 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.232 ns/day, 19.476 hours/ns, 14.263 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    | 69.32      | 69.32      | 69.32      |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13057    | 0.13057    | 0.13057    |   0.0 |  0.19
Output  | 0.00017489 | 0.00017489 | 0.00017489 |   0.0 |  0.00
Modify  | 0.58244    | 0.58244    | 0.58244    |   0.0 |  0.83
Other   |            | 0.08068    |            |       |  0.12

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:      889668.0 ave      889668 max      889668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889668
Ave neighs/atom = 222.41700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.787405273172, Press = 0.0351387211274928
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   61000   -17513.949   -17513.949   -17654.012   -17654.012    270.95963    270.95963     43813.66     43813.66    2911.7085    2911.7085 
   62000   -17510.542   -17510.542    -17651.62    -17651.62    272.92538    272.92538    43841.719    43841.719    2065.7558    2065.7558 
Loop time of 70.2197 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.230 ns/day, 19.505 hours/ns, 14.241 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    | 69.422     | 69.422     | 69.422     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13072    | 0.13072    | 0.13072    |   0.0 |  0.19
Output  | 0.00017464 | 0.00017464 | 0.00017464 |   0.0 |  0.00
Modify  | 0.58496    | 0.58496    | 0.58496    |   0.0 |  0.83
Other   |            | 0.08134    |            |       |  0.12

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:      890556.0 ave      890556 max      890556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890556
Ave neighs/atom = 222.63900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.796334994758, Press = 1.24106378645607
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   62000   -17510.542   -17510.542    -17651.62    -17651.62    272.92538    272.92538    43841.719    43841.719    2065.7558    2065.7558 
   63000   -17513.409   -17513.409   -17650.431   -17650.431    265.07722    265.07722    43903.492    43903.492   -451.15748   -451.15748 
Loop time of 69.9426 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.235 ns/day, 19.429 hours/ns, 14.297 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    | 69.152     | 69.152     | 69.152     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13006    | 0.13006    | 0.13006    |   0.0 |  0.19
Output  | 0.00018118 | 0.00018118 | 0.00018118 |   0.0 |  0.00
Modify  | 0.57958    | 0.57958    | 0.57958    |   0.0 |  0.83
Other   |            | 0.08052    |            |       |  0.12

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:      890330.0 ave      890330 max      890330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890330
Ave neighs/atom = 222.58250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.800632893929, Press = 0.95979871905576
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   63000   -17513.409   -17513.409   -17650.431   -17650.431    265.07722    265.07722    43903.492    43903.492   -451.15748   -451.15748 
   64000   -17507.712   -17507.712   -17650.989   -17650.989    277.17922    277.17922    43929.589    43929.589   -1319.8651   -1319.8651 
Loop time of 69.9489 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.235 ns/day, 19.430 hours/ns, 14.296 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    | 69.162     | 69.162     | 69.162     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12947    | 0.12947    | 0.12947    |   0.0 |  0.19
Output  | 0.00013041 | 0.00013041 | 0.00013041 |   0.0 |  0.00
Modify  | 0.57778    | 0.57778    | 0.57778    |   0.0 |  0.83
Other   |            | 0.08003    |            |       |  0.11

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:      889228.0 ave      889228 max      889228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889228
Ave neighs/atom = 222.30700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.804769937191, Press = 0.268807155176197
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   64000   -17507.712   -17507.712   -17650.989   -17650.989    277.17922    277.17922    43929.589    43929.589   -1319.8651   -1319.8651 
   65000   -17511.072   -17511.072   -17654.641   -17654.641    277.74337    277.74337    43893.783    43893.783   -146.75106   -146.75106 
Loop time of 70.0246 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.234 ns/day, 19.451 hours/ns, 14.281 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    | 69.231     | 69.231     | 69.231     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13029    | 0.13029    | 0.13029    |   0.0 |  0.19
Output  | 0.00017256 | 0.00017256 | 0.00017256 |   0.0 |  0.00
Modify  | 0.58166    | 0.58166    | 0.58166    |   0.0 |  0.83
Other   |            | 0.08106    |            |       |  0.12

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:      888980.0 ave      888980 max      888980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 888980
Ave neighs/atom = 222.24500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.788046181032, Press = -0.175661324325107
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   65000   -17511.072   -17511.072   -17654.641   -17654.641    277.74337    277.74337    43893.783    43893.783   -146.75106   -146.75106 
   66000   -17511.938   -17511.938   -17654.205   -17654.205     275.2253     275.2253        43828        43828    2438.8557    2438.8557 
Loop time of 70.1714 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.231 ns/day, 19.492 hours/ns, 14.251 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    | 69.373     | 69.373     | 69.373     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13045    | 0.13045    | 0.13045    |   0.0 |  0.19
Output  | 0.00017044 | 0.00017044 | 0.00017044 |   0.0 |  0.00
Modify  | 0.58573    | 0.58573    | 0.58573    |   0.0 |  0.83
Other   |            | 0.08253    |            |       |  0.12

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:      889652.0 ave      889652 max      889652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889652
Ave neighs/atom = 222.41300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.787116555847, Press = 0.0110835934069581
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   66000   -17511.938   -17511.938   -17654.205   -17654.205     275.2253     275.2253        43828        43828    2438.8557    2438.8557 
   67000     -17511.9     -17511.9   -17654.009   -17654.009    274.92019    274.92019    43836.658    43836.658    2115.9413    2115.9413 
Loop time of 70.0887 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.233 ns/day, 19.469 hours/ns, 14.268 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    | 69.297     | 69.297     | 69.297     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12972    | 0.12972    | 0.12972    |   0.0 |  0.19
Output  | 0.00016954 | 0.00016954 | 0.00016954 |   0.0 |  0.00
Modify  | 0.58151    | 0.58151    | 0.58151    |   0.0 |  0.83
Other   |            | 0.08074    |            |       |  0.12

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:      890414.0 ave      890414 max      890414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890414
Ave neighs/atom = 222.60350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.765919549944, Press = 1.4372020142904
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   67000     -17511.9     -17511.9   -17654.009   -17654.009    274.92019    274.92019    43836.658    43836.658    2115.9413    2115.9413 
   68000   -17511.987   -17511.987   -17651.293   -17651.293    269.49541    269.49541    43908.736    43908.736   -611.84103   -611.84103 
Loop time of 67.7165 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.276 ns/day, 18.810 hours/ns, 14.767 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    | 66.946     | 66.946     | 66.946     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12629    | 0.12629    | 0.12629    |   0.0 |  0.19
Output  | 0.00017476 | 0.00017476 | 0.00017476 |   0.0 |  0.00
Modify  | 0.56414    | 0.56414    | 0.56414    |   0.0 |  0.83
Other   |            | 0.07959    |            |       |  0.12

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:      890232.0 ave      890232 max      890232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890232
Ave neighs/atom = 222.55800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.768261636912, Press = 0.939215466125949
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   68000   -17511.987   -17511.987   -17651.293   -17651.293    269.49541    269.49541    43908.736    43908.736   -611.84103   -611.84103 
   69000   -17515.043   -17515.043   -17654.221   -17654.221    269.24937    269.24937     43922.78     43922.78   -1332.1741   -1332.1741 
Loop time of 69.4188 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.245 ns/day, 19.283 hours/ns, 14.405 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    | 68.648     | 68.648     | 68.648     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12753    | 0.12753    | 0.12753    |   0.0 |  0.18
Output  | 0.00017438 | 0.00017438 | 0.00017438 |   0.0 |  0.00
Modify  | 0.56599    | 0.56599    | 0.56599    |   0.0 |  0.82
Other   |            | 0.07732    |            |       |  0.11

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:      889354.0 ave      889354 max      889354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889354
Ave neighs/atom = 222.33850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.737561221082, Press = 0.231390069794501
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   69000   -17515.043   -17515.043   -17654.221   -17654.221    269.24937    269.24937     43922.78     43922.78   -1332.1741   -1332.1741 
   70000   -17513.545   -17513.545   -17652.011   -17652.011     267.8726     267.8726    43890.636    43890.636    1.9889357    1.9889357 
Loop time of 69.5857 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.242 ns/day, 19.329 hours/ns, 14.371 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    | 68.807     | 68.807     | 68.807     |   0.0 | 98.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12813    | 0.12813    | 0.12813    |   0.0 |  0.18
Output  | 0.0001718  | 0.0001718  | 0.0001718  |   0.0 |  0.00
Modify  | 0.57142    | 0.57142    | 0.57142    |   0.0 |  0.82
Other   |            | 0.07861    |            |       |  0.11

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:      889592.0 ave      889592 max      889592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889592
Ave neighs/atom = 222.39800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.741867070666, Press = -0.185980694134207
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   70000   -17513.545   -17513.545   -17652.011   -17652.011     267.8726     267.8726    43890.636    43890.636    1.9889357    1.9889357 
   71000   -17510.905   -17510.905   -17652.095   -17652.095    273.14239    273.14239    43847.099    43847.099    1800.3173    1800.3173 
Loop time of 69.9567 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.235 ns/day, 19.432 hours/ns, 14.295 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    | 69.17      | 69.17      | 69.17      |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12937    | 0.12937    | 0.12937    |   0.0 |  0.18
Output  | 0.00017722 | 0.00017722 | 0.00017722 |   0.0 |  0.00
Modify  | 0.57707    | 0.57707    | 0.57707    |   0.0 |  0.82
Other   |            | 0.08048    |            |       |  0.12

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:      889854.0 ave      889854 max      889854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889854
Ave neighs/atom = 222.46350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.745491103605, Press = 0.165510124515289
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   71000   -17510.905   -17510.905   -17652.095   -17652.095    273.14239    273.14239    43847.099    43847.099    1800.3173    1800.3173 
   72000   -17513.482   -17513.482   -17653.353   -17653.353    270.58917    270.58917    43826.659    43826.659    2518.0416    2518.0416 
Loop time of 70.2361 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.230 ns/day, 19.510 hours/ns, 14.238 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    | 69.436     | 69.436     | 69.436     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13157    | 0.13157    | 0.13157    |   0.0 |  0.19
Output  | 0.00017425 | 0.00017425 | 0.00017425 |   0.0 |  0.00
Modify  | 0.58546    | 0.58546    | 0.58546    |   0.0 |  0.83
Other   |            | 0.08317    |            |       |  0.12

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:      890236.0 ave      890236 max      890236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890236
Ave neighs/atom = 222.55900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.760963677743, Press = 1.73758499746578
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   72000   -17513.482   -17513.482   -17653.353   -17653.353    270.58917    270.58917    43826.659    43826.659    2518.0416    2518.0416 
   73000    -17510.08    -17510.08    -17651.66    -17651.66     273.8952     273.8952    43927.335    43927.335   -1349.6979   -1349.6979 
Loop time of 69.6047 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.241 ns/day, 19.335 hours/ns, 14.367 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    | 68.827     | 68.827     | 68.827     |   0.0 | 98.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12781    | 0.12781    | 0.12781    |   0.0 |  0.18
Output  | 0.00013039 | 0.00013039 | 0.00013039 |   0.0 |  0.00
Modify  | 0.57124    | 0.57124    | 0.57124    |   0.0 |  0.82
Other   |            | 0.07828    |            |       |  0.11

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:      890328.0 ave      890328 max      890328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890328
Ave neighs/atom = 222.58200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.77026875881, Press = 0.998542916438218
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   73000    -17510.08    -17510.08    -17651.66    -17651.66     273.8952     273.8952    43927.335    43927.335   -1349.6979   -1349.6979 
   74000   -17509.517   -17509.517   -17651.128   -17651.128    273.95598    273.95598     43927.55     43927.55   -1335.5322   -1335.5322 
Loop time of 70.1285 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.232 ns/day, 19.480 hours/ns, 14.260 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    | 69.337     | 69.337     | 69.337     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13007    | 0.13007    | 0.13007    |   0.0 |  0.19
Output  | 0.00017925 | 0.00017925 | 0.00017925 |   0.0 |  0.00
Modify  | 0.5803     | 0.5803     | 0.5803     |   0.0 |  0.83
Other   |            | 0.08124    |            |       |  0.12

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:      889334.0 ave      889334 max      889334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889334
Ave neighs/atom = 222.33350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.757039062189, Press = 0.242011527098748
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   74000   -17509.517   -17509.517   -17651.128   -17651.128    273.95598    273.95598     43927.55     43927.55   -1335.5322   -1335.5322 
   75000   -17513.995   -17513.995   -17654.182   -17654.182    271.20071    271.20071    43894.907    43894.907   -309.56575   -309.56575 
Loop time of 70.0884 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.233 ns/day, 19.469 hours/ns, 14.268 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    | 69.296     | 69.296     | 69.296     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12999    | 0.12999    | 0.12999    |   0.0 |  0.19
Output  | 0.00017739 | 0.00017739 | 0.00017739 |   0.0 |  0.00
Modify  | 0.58108    | 0.58108    | 0.58108    |   0.0 |  0.83
Other   |            | 0.0808     |            |       |  0.12

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:      889166.0 ave      889166 max      889166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889166
Ave neighs/atom = 222.29150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.743834476711, Press = -0.113378984405083
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   75000   -17513.995   -17513.995   -17654.182   -17654.182    271.20071    271.20071    43894.907    43894.907   -309.56575   -309.56575 
   76000   -17505.761   -17505.761   -17647.768   -17647.768    274.72203    274.72203    43854.958    43854.958    1757.8484    1757.8484 
Loop time of 70.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.232 ns/day, 19.482 hours/ns, 14.258 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    | 69.342     | 69.342     | 69.342     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13007    | 0.13007    | 0.13007    |   0.0 |  0.19
Output  | 0.0001819  | 0.0001819  | 0.0001819  |   0.0 |  0.00
Modify  | 0.58247    | 0.58247    | 0.58247    |   0.0 |  0.83
Other   |            | 0.0816     |            |       |  0.12

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:      889774.0 ave      889774 max      889774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889774
Ave neighs/atom = 222.44350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.762206581214, Press = 0.172131929841544
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   76000   -17505.761   -17505.761   -17647.768   -17647.768    274.72203    274.72203    43854.958    43854.958    1757.8484    1757.8484 
   77000   -17510.349   -17510.349    -17652.29    -17652.29    274.59389    274.59389    43835.367    43835.367    2328.3006    2328.3006 
Loop time of 69.6462 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.241 ns/day, 19.346 hours/ns, 14.358 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    | 68.869     | 68.869     | 68.869     |   0.0 | 98.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12842    | 0.12842    | 0.12842    |   0.0 |  0.18
Output  | 0.00013148 | 0.00013148 | 0.00013148 |   0.0 |  0.00
Modify  | 0.57089    | 0.57089    | 0.57089    |   0.0 |  0.82
Other   |            | 0.07824    |            |       |  0.11

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:      889880.0 ave      889880 max      889880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889880
Ave neighs/atom = 222.47000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.775025471343, Press = 1.36481621866752
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   77000   -17510.349   -17510.349    -17652.29    -17652.29    274.59389    274.59389    43835.367    43835.367    2328.3006    2328.3006 
   78000    -17517.95    -17517.95   -17654.611   -17654.611    264.38019    264.38019    43907.462    43907.462   -904.60824   -904.60824 
Loop time of 49.3142 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.752 ns/day, 13.698 hours/ns, 20.278 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    | 48.733     | 48.733     | 48.733     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092338   | 0.092338   | 0.092338   |   0.0 |  0.19
Output  | 0.00011508 | 0.00011508 | 0.00011508 |   0.0 |  0.00
Modify  | 0.42225    | 0.42225    | 0.42225    |   0.0 |  0.86
Other   |            | 0.066      |            |       |  0.13

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:      890260.0 ave      890260 max      890260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890260
Ave neighs/atom = 222.56500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.770495117453, Press = 1.18354746186902
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   78000    -17517.95    -17517.95   -17654.611   -17654.611    264.38019    264.38019    43907.462    43907.462   -904.60824   -904.60824 
   79000   -17510.219   -17510.219   -17653.563   -17653.563    277.30797    277.30797    43924.415    43924.415   -1373.5546   -1373.5546 
Loop time of 46.3678 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.863 ns/day, 12.880 hours/ns, 21.567 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    | 45.831     | 45.831     | 45.831     |   0.0 | 98.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086112   | 0.086112   | 0.086112   |   0.0 |  0.19
Output  | 0.00017384 | 0.00017384 | 0.00017384 |   0.0 |  0.00
Modify  | 0.38932    | 0.38932    | 0.38932    |   0.0 |  0.84
Other   |            | 0.06171    |            |       |  0.13

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:      889592.0 ave      889592 max      889592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889592
Ave neighs/atom = 222.39800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.75764816325, Press = 0.323570568885207
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   79000   -17510.219   -17510.219   -17653.563   -17653.563    277.30797    277.30797    43924.415    43924.415   -1373.5546   -1373.5546 
   80000   -17513.883   -17513.883    -17653.43    -17653.43    269.96342    269.96342    43892.129    43892.129   -158.78014   -158.78014 
Loop time of 66.3707 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.302 ns/day, 18.436 hours/ns, 15.067 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    | 65.608     | 65.608     | 65.608     |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1245     | 0.1245     | 0.1245     |   0.0 |  0.19
Output  | 7.5947e-05 | 7.5947e-05 | 7.5947e-05 |   0.0 |  0.00
Modify  | 0.55775    | 0.55775    | 0.55775    |   0.0 |  0.84
Other   |            | 0.08014    |            |       |  0.12

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:      889378.0 ave      889378 max      889378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889378
Ave neighs/atom = 222.34450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.742055331457, Press = 0.0782705076000131
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   80000   -17513.883   -17513.883    -17653.43    -17653.43    269.96342    269.96342    43892.129    43892.129   -158.78014   -158.78014 
   81000   -17513.355   -17513.355   -17652.429   -17652.429    269.04686    269.04686    43867.736    43867.736    894.71555    894.71555 
Loop time of 33.6036 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.571 ns/day, 9.334 hours/ns, 29.759 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    | 33.217     | 33.217     | 33.217     |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062464   | 0.062464   | 0.062464   |   0.0 |  0.19
Output  | 0.00010333 | 0.00010333 | 0.00010333 |   0.0 |  0.00
Modify  | 0.28206    | 0.28206    | 0.28206    |   0.0 |  0.84
Other   |            | 0.04214    |            |       |  0.13

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:      889670.0 ave      889670 max      889670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889670
Ave neighs/atom = 222.41750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.752029957243, Press = 0.189020311912363
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   81000   -17513.355   -17513.355   -17652.429   -17652.429    269.04686    269.04686    43867.736    43867.736    894.71555    894.71555 
   82000   -17512.797   -17512.797   -17654.561   -17654.561    274.25279    274.25279    43843.287    43843.287    1887.1339    1887.1339 
Loop time of 34.1523 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.530 ns/day, 9.487 hours/ns, 29.281 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    | 33.749     | 33.749     | 33.749     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064108   | 0.064108   | 0.064108   |   0.0 |  0.19
Output  | 0.00017751 | 0.00017751 | 0.00017751 |   0.0 |  0.00
Modify  | 0.29382    | 0.29382    | 0.29382    |   0.0 |  0.86
Other   |            | 0.04561    |            |       |  0.13

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:      889990.0 ave      889990 max      889990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889990
Ave neighs/atom = 222.49750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.771037374318, Press = 1.01419491652063
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   82000   -17512.797   -17512.797   -17654.561   -17654.561    274.25279    274.25279    43843.287    43843.287    1887.1339    1887.1339 
   83000   -17503.632   -17503.632   -17648.817   -17648.817    280.87041    280.87041    43932.731    43932.731   -1252.6365   -1252.6365 
Loop time of 40.2411 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.147 ns/day, 11.178 hours/ns, 24.850 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    | 39.768     | 39.768     | 39.768     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075888   | 0.075888   | 0.075888   |   0.0 |  0.19
Output  | 9.9008e-05 | 9.9008e-05 | 9.9008e-05 |   0.0 |  0.00
Modify  | 0.34384    | 0.34384    | 0.34384    |   0.0 |  0.85
Other   |            | 0.05327    |            |       |  0.13

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:      890312.0 ave      890312 max      890312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890312
Ave neighs/atom = 222.57800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.795982382503, Press = 1.12048193146659
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   83000   -17503.632   -17503.632   -17648.817   -17648.817    280.87041    280.87041    43932.731    43932.731   -1252.6365   -1252.6365 
   84000   -17513.514   -17513.514   -17653.208   -17653.208    270.24761    270.24761    43937.543    43937.543   -1851.6393   -1851.6393 
Loop time of 35.3786 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.442 ns/day, 9.827 hours/ns, 28.266 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    | 34.964     | 34.964     | 34.964     |   0.0 | 98.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066233   | 0.066233   | 0.066233   |   0.0 |  0.19
Output  | 0.00013528 | 0.00013528 | 0.00013528 |   0.0 |  0.00
Modify  | 0.30163    | 0.30163    | 0.30163    |   0.0 |  0.85
Other   |            | 0.04639    |            |       |  0.13

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:      889114.0 ave      889114 max      889114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889114
Ave neighs/atom = 222.27850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.809810581552, Press = 0.182141891993425
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   84000   -17513.514   -17513.514   -17653.208   -17653.208    270.24761    270.24761    43937.543    43937.543   -1851.6393   -1851.6393 
   85000   -17509.333   -17509.333   -17653.784   -17653.784    279.45051    279.45051    43902.488    43902.488   -409.59741   -409.59741 
Loop time of 39.2417 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.202 ns/day, 10.900 hours/ns, 25.483 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    | 38.777     | 38.777     | 38.777     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073668   | 0.073668   | 0.073668   |   0.0 |  0.19
Output  | 9.9074e-05 | 9.9074e-05 | 9.9074e-05 |   0.0 |  0.00
Modify  | 0.33912    | 0.33912    | 0.33912    |   0.0 |  0.86
Other   |            | 0.0516     |            |       |  0.13

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:      889462.0 ave      889462 max      889462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889462
Ave neighs/atom = 222.36550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.817128697871, Press = -0.0800286603138451
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   85000   -17509.333   -17509.333   -17653.784   -17653.784    279.45051    279.45051    43902.488    43902.488   -409.59741   -409.59741 
   86000   -17514.095   -17514.095   -17655.229   -17655.229    273.03246    273.03246    43855.092    43855.092    1367.2468    1367.2468 
Loop time of 33.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.568 ns/day, 9.347 hours/ns, 29.719 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    | 33.26      | 33.26      | 33.26      |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062576   | 0.062576   | 0.062576   |   0.0 |  0.19
Output  | 0.00010017 | 0.00010017 | 0.00010017 |   0.0 |  0.00
Modify  | 0.28331    | 0.28331    | 0.28331    |   0.0 |  0.84
Other   |            | 0.04242    |            |       |  0.13

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:      889732.0 ave      889732 max      889732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889732
Ave neighs/atom = 222.43300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.813532367428, Press = 0.33578653479916
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   86000   -17514.095   -17514.095   -17655.229   -17655.229    273.03246    273.03246    43855.092    43855.092    1367.2468    1367.2468 
   87000   -17503.982   -17503.982   -17647.613   -17647.613    277.86322    277.86322    43876.302    43876.302    915.17838    915.17838 
Loop time of 34.0649 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.536 ns/day, 9.462 hours/ns, 29.356 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    | 33.665     | 33.665     | 33.665     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063869   | 0.063869   | 0.063869   |   0.0 |  0.19
Output  | 8.6437e-05 | 8.6437e-05 | 8.6437e-05 |   0.0 |  0.00
Modify  | 0.29138    | 0.29138    | 0.29138    |   0.0 |  0.86
Other   |            | 0.04498    |            |       |  0.13

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:      890364.0 ave      890364 max      890364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890364
Ave neighs/atom = 222.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 = 272.831893608873, Press = 0.892332896769317
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   87000   -17503.982   -17503.982   -17647.613   -17647.613    277.86322    277.86322    43876.302    43876.302    915.17838    915.17838 
   88000   -17511.422   -17511.422    -17654.15    -17654.15    276.11802    276.11802    43919.496    43919.496   -1171.9177   -1171.9177 
Loop time of 33.659 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.567 ns/day, 9.350 hours/ns, 29.710 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    | 33.271     | 33.271     | 33.271     |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062324   | 0.062324   | 0.062324   |   0.0 |  0.19
Output  | 0.00010096 | 0.00010096 | 0.00010096 |   0.0 |  0.00
Modify  | 0.28248    | 0.28248    | 0.28248    |   0.0 |  0.84
Other   |            | 0.04284    |            |       |  0.13

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:      889394.0 ave      889394 max      889394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889394
Ave neighs/atom = 222.34850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.848717738787, Press = 0.78555925630601
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   88000   -17511.422   -17511.422    -17654.15    -17654.15    276.11802    276.11802    43919.496    43919.496   -1171.9177   -1171.9177 
   89000   -17504.674   -17504.674   -17651.171   -17651.171    283.40812    283.40812    43942.171    43942.171   -1711.2883   -1711.2883 
Loop time of 33.9392 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.546 ns/day, 9.428 hours/ns, 29.464 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    | 33.543     | 33.543     | 33.543     |   0.0 | 98.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063399   | 0.063399   | 0.063399   |   0.0 |  0.19
Output  | 7.6382e-05 | 7.6382e-05 | 7.6382e-05 |   0.0 |  0.00
Modify  | 0.28828    | 0.28828    | 0.28828    |   0.0 |  0.85
Other   |            | 0.04489    |            |       |  0.13

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:      889596.0 ave      889596 max      889596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889596
Ave neighs/atom = 222.39900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.876572041958, Press = 0.175054113451464
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   89000   -17504.674   -17504.674   -17651.171   -17651.171    283.40812    283.40812    43942.171    43942.171   -1711.2883   -1711.2883 
   90000   -17510.059   -17510.059   -17654.069   -17654.069    278.59648    278.59648    43903.148    43903.148   -477.96892   -477.96892 
Loop time of 34.5408 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.501 ns/day, 9.595 hours/ns, 28.951 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    | 34.128     | 34.128     | 34.128     |   0.0 | 98.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065191   | 0.065191   | 0.065191   |   0.0 |  0.19
Output  | 9.6962e-05 | 9.6962e-05 | 9.6962e-05 |   0.0 |  0.00
Modify  | 0.30121    | 0.30121    | 0.30121    |   0.0 |  0.87
Other   |            | 0.04663    |            |       |  0.13

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:      888944.0 ave      888944 max      888944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 888944
Ave neighs/atom = 222.23600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883176454478, Press = -0.197244863175592
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   90000   -17510.059   -17510.059   -17654.069   -17654.069    278.59648    278.59648    43903.148    43903.148   -477.96892   -477.96892 
   91000   -17516.718   -17516.718   -17655.655   -17655.655    268.78302    268.78302    43839.472    43839.472    1875.8472    1875.8472 
Loop time of 33.6887 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.565 ns/day, 9.358 hours/ns, 29.684 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    | 33.299     | 33.299     | 33.299     |   0.0 | 98.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062583   | 0.062583   | 0.062583   |   0.0 |  0.19
Output  | 7.4992e-05 | 7.4992e-05 | 7.4992e-05 |   0.0 |  0.00
Modify  | 0.28414    | 0.28414    | 0.28414    |   0.0 |  0.84
Other   |            | 0.04247    |            |       |  0.13

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:      889688.0 ave      889688 max      889688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889688
Ave neighs/atom = 222.42200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.876527346039, Press = 0.0876520388089603
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   91000   -17516.718   -17516.718   -17655.655   -17655.655    268.78302    268.78302    43839.472    43839.472    1875.8472    1875.8472 
   92000   -17508.751   -17508.751   -17650.771   -17650.771    274.74685    274.74685    43860.161    43860.161    1354.0841    1354.0841 
Loop time of 34.5429 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.501 ns/day, 9.595 hours/ns, 28.949 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    | 34.132     | 34.132     | 34.132     |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065553   | 0.065553   | 0.065553   |   0.0 |  0.19
Output  | 9.8546e-05 | 9.8546e-05 | 9.8546e-05 |   0.0 |  0.00
Modify  | 0.29853    | 0.29853    | 0.29853    |   0.0 |  0.86
Other   |            | 0.04654    |            |       |  0.13

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:      890438.0 ave      890438 max      890438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890438
Ave neighs/atom = 222.60950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.871733164069, Press = 0.809025272170859
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   92000   -17508.751   -17508.751   -17650.771   -17650.771    274.74685    274.74685    43860.161    43860.161    1354.0841    1354.0841 
   93000   -17513.446   -17513.446   -17652.468   -17652.468    268.94877    268.94877    43904.692    43904.692   -607.15483   -607.15483 
Loop time of 36.3921 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.374 ns/day, 10.109 hours/ns, 27.478 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    | 35.972     | 35.972     | 35.972     |   0.0 | 98.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06753    | 0.06753    | 0.06753    |   0.0 |  0.19
Output  | 9.75e-05   | 9.75e-05   | 9.75e-05   |   0.0 |  0.00
Modify  | 0.3059     | 0.3059     | 0.3059     |   0.0 |  0.84
Other   |            | 0.04663    |            |       |  0.13

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:      890108.0 ave      890108 max      890108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890108
Ave neighs/atom = 222.52700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.879717281607, Press = 0.624262797818521
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   93000   -17513.446   -17513.446   -17652.468   -17652.468    268.94877    268.94877    43904.692    43904.692   -607.15483   -607.15483 
   94000   -17506.743   -17506.743   -17649.494   -17649.494    276.16121    276.16121    43920.588    43920.588   -868.25067   -868.25067 
Loop time of 38.1699 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.264 ns/day, 10.603 hours/ns, 26.199 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    | 37.744     | 37.744     | 37.744     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069411   | 0.069411   | 0.069411   |   0.0 |  0.18
Output  | 0.00013071 | 0.00013071 | 0.00013071 |   0.0 |  0.00
Modify  | 0.31229    | 0.31229    | 0.31229    |   0.0 |  0.82
Other   |            | 0.04366    |            |       |  0.11

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:      889646.0 ave      889646 max      889646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889646
Ave neighs/atom = 222.41150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.892177340125, Press = 0.326554424647505
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   94000   -17506.743   -17506.743   -17649.494   -17649.494    276.16121    276.16121    43920.588    43920.588   -868.25067   -868.25067 
   95000   -17512.092   -17512.092   -17652.667   -17652.667    271.95219    271.95219     43898.38     43898.38   -173.65154   -173.65154 
Loop time of 43.0135 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.009 ns/day, 11.948 hours/ns, 23.249 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    | 42.536     | 42.536     | 42.536     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0785     | 0.0785     | 0.0785     |   0.0 |  0.18
Output  | 0.00010087 | 0.00010087 | 0.00010087 |   0.0 |  0.00
Modify  | 0.3507     | 0.3507     | 0.3507     |   0.0 |  0.82
Other   |            | 0.04826    |            |       |  0.11

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:      889182.0 ave      889182 max      889182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889182
Ave neighs/atom = 222.29550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.908774554061, Press = 0.195846296877782
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   95000   -17512.092   -17512.092   -17652.667   -17652.667    271.95219    271.95219     43898.38     43898.38   -173.65154   -173.65154 
   96000   -17510.436   -17510.436   -17652.735   -17652.735    275.28834    275.28834    43875.727    43875.727    642.22244    642.22244 
Loop time of 36.4701 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.369 ns/day, 10.131 hours/ns, 27.420 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    | 36.036     | 36.036     | 36.036     |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069047   | 0.069047   | 0.069047   |   0.0 |  0.19
Output  | 9.8492e-05 | 9.8492e-05 | 9.8492e-05 |   0.0 |  0.00
Modify  | 0.31497    | 0.31497    | 0.31497    |   0.0 |  0.86
Other   |            | 0.04966    |            |       |  0.14

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:      889614.0 ave      889614 max      889614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889614
Ave neighs/atom = 222.40350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.915581382653, Press = 0.209125780277512
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   96000   -17510.436   -17510.436   -17652.735   -17652.735    275.28834    275.28834    43875.727    43875.727    642.22244    642.22244 
   97000   -17514.371   -17514.371   -17656.554   -17656.554    275.06433    275.06433    43870.275    43870.275    641.68345    641.68345 
Loop time of 33.447 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.583 ns/day, 9.291 hours/ns, 29.898 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    | 33.07      | 33.07      | 33.07      |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061361   | 0.061361   | 0.061361   |   0.0 |  0.18
Output  | 9.8378e-05 | 9.8378e-05 | 9.8378e-05 |   0.0 |  0.00
Modify  | 0.27619    | 0.27619    | 0.27619    |   0.0 |  0.83
Other   |            | 0.03982    |            |       |  0.12

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:      889916.0 ave      889916 max      889916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889916
Ave neighs/atom = 222.47900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.910480589261, Press = 0.479724809119107
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   97000   -17514.371   -17514.371   -17656.554   -17656.554    275.06433    275.06433    43870.275    43870.275    641.68345    641.68345 
   98000   -17510.727   -17510.727   -17651.682   -17651.682    272.68682    272.68682    43898.651    43898.651   -235.69857   -235.69857 
Loop time of 34.4788 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.506 ns/day, 9.577 hours/ns, 29.003 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    | 34.088     | 34.088     | 34.088     |   0.0 | 98.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06327    | 0.06327    | 0.06327    |   0.0 |  0.18
Output  | 0.00021363 | 0.00021363 | 0.00021363 |   0.0 |  0.00
Modify  | 0.28582    | 0.28582    | 0.28582    |   0.0 |  0.83
Other   |            | 0.04184    |            |       |  0.12

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:      890376.0 ave      890376 max      890376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890376
Ave neighs/atom = 222.59400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.906381506564, Press = 0.847174886116306
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   98000   -17510.727   -17510.727   -17651.682   -17651.682    272.68682    272.68682    43898.651    43898.651   -235.69857   -235.69857 
   99000   -17519.347   -17519.347   -17655.685   -17655.685    263.75435    263.75435    43935.173    43935.173   -1990.3562   -1990.3562 
Loop time of 39.5138 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.187 ns/day, 10.976 hours/ns, 25.308 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    | 39.049     | 39.049     | 39.049     |   0.0 | 98.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074076   | 0.074076   | 0.074076   |   0.0 |  0.19
Output  | 9.8136e-05 | 9.8136e-05 | 9.8136e-05 |   0.0 |  0.00
Modify  | 0.33925    | 0.33925    | 0.33925    |   0.0 |  0.86
Other   |            | 0.05112    |            |       |  0.13

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:      889624.0 ave      889624 max      889624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889624
Ave neighs/atom = 222.40600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.895583315101, Press = 0.376056387758055
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
   99000   -17519.347   -17519.347   -17655.685   -17655.685    263.75435    263.75435    43935.173    43935.173   -1990.3562   -1990.3562 
  100000    -17508.32    -17508.32   -17654.153   -17654.153    282.12356    282.12356    43925.222    43925.222   -1331.0445   -1331.0445 
Loop time of 33.3721 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.589 ns/day, 9.270 hours/ns, 29.965 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    | 32.997     | 32.997     | 32.997     |   0.0 | 98.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060987   | 0.060987   | 0.060987   |   0.0 |  0.18
Output  | 7.2911e-05 | 7.2911e-05 | 7.2911e-05 |   0.0 |  0.00
Modify  | 0.27484    | 0.27484    | 0.27484    |   0.0 |  0.82
Other   |            | 0.03892    |            |       |  0.12

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:      889326.0 ave      889326 max      889326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889326
Ave neighs/atom = 222.33150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883687824933, Press = -0.0874358612642095
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  100000    -17508.32    -17508.32   -17654.153   -17654.153    282.12356    282.12356    43925.222    43925.222   -1331.0445   -1331.0445 
  101000   -17511.545   -17511.545    -17652.92    -17652.92    273.49812    273.49812    43888.814    43888.814     119.6194     119.6194 
Loop time of 43.2308 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.999 ns/day, 12.009 hours/ns, 23.132 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    | 42.751     | 42.751     | 42.751     |   0.0 | 98.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078619   | 0.078619   | 0.078619   |   0.0 |  0.18
Output  | 8.1857e-05 | 8.1857e-05 | 8.1857e-05 |   0.0 |  0.00
Modify  | 0.35234    | 0.35234    | 0.35234    |   0.0 |  0.82
Other   |            | 0.04841    |            |       |  0.11

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:      889416.0 ave      889416 max      889416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889416
Ave neighs/atom = 222.35400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.890948318483, Press = 0.096974203643295
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  101000   -17511.545   -17511.545    -17652.92    -17652.92    273.49812    273.49812    43888.814    43888.814     119.6194     119.6194 
  102000   -17510.916   -17510.916   -17651.153   -17651.153    271.29779    271.29779    43876.789    43876.789     624.8194     624.8194 
Loop time of 33.5565 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.575 ns/day, 9.321 hours/ns, 29.800 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    | 33.175     | 33.175     | 33.175     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061832   | 0.061832   | 0.061832   |   0.0 |  0.18
Output  | 0.00010276 | 0.00010276 | 0.00010276 |   0.0 |  0.00
Modify  | 0.27895    | 0.27895    | 0.27895    |   0.0 |  0.83
Other   |            | 0.04026    |            |       |  0.12

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:      889660.0 ave      889660 max      889660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889660
Ave neighs/atom = 222.41500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.912796013729, Press = 0.19298207633673
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  102000   -17510.916   -17510.916   -17651.153   -17651.153    271.29779    271.29779    43876.789    43876.789     624.8194     624.8194 
  103000   -17508.643   -17508.643   -17652.248   -17652.248    277.81395    277.81395    43892.407    43892.407    65.708326    65.708326 
Loop time of 34.3815 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.513 ns/day, 9.550 hours/ns, 29.085 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    | 33.971     | 33.971     | 33.971     |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065565   | 0.065565   | 0.065565   |   0.0 |  0.19
Output  | 9.8721e-05 | 9.8721e-05 | 9.8721e-05 |   0.0 |  0.00
Modify  | 0.29834    | 0.29834    | 0.29834    |   0.0 |  0.87
Other   |            | 0.04656    |            |       |  0.14

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:      889756.0 ave      889756 max      889756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889756
Ave neighs/atom = 222.43900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.918228082892, Press = 0.400732826704807
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  103000   -17508.643   -17508.643   -17652.248   -17652.248    277.81395    277.81395    43892.407    43892.407    65.708326    65.708326 
  104000   -17515.349   -17515.349   -17653.568   -17653.568    267.39476    267.39476    43907.574    43907.574    -830.2169    -830.2169 
Loop time of 33.5457 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.576 ns/day, 9.318 hours/ns, 29.810 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    | 33.163     | 33.163     | 33.163     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061927   | 0.061927   | 0.061927   |   0.0 |  0.18
Output  | 7.4985e-05 | 7.4985e-05 | 7.4985e-05 |   0.0 |  0.00
Modify  | 0.27941    | 0.27941    | 0.27941    |   0.0 |  0.83
Other   |            | 0.04121    |            |       |  0.12

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:      889506.0 ave      889506 max      889506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889506
Ave neighs/atom = 222.37650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.922025776634, Press = 0.259192122991074
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  104000   -17515.349   -17515.349   -17653.568   -17653.568    267.39476    267.39476    43907.574    43907.574    -830.2169    -830.2169 
  105000   -17511.669   -17511.669   -17652.521   -17652.521    272.48849    272.48849    43908.159    43908.159   -681.12457   -681.12457 
Loop time of 34.6272 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.495 ns/day, 9.619 hours/ns, 28.879 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    | 34.213     | 34.213     | 34.213     |   0.0 | 98.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06575    | 0.06575    | 0.06575    |   0.0 |  0.19
Output  | 7.2822e-05 | 7.2822e-05 | 7.2822e-05 |   0.0 |  0.00
Modify  | 0.30191    | 0.30191    | 0.30191    |   0.0 |  0.87
Other   |            | 0.04683    |            |       |  0.14

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:      889476.0 ave      889476 max      889476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889476
Ave neighs/atom = 222.36900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.920949840408, Press = -0.345913538563326
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  105000   -17511.669   -17511.669   -17652.521   -17652.521    272.48849    272.48849    43908.159    43908.159   -681.12457   -681.12457 
  106000   -17506.777   -17506.777   -17649.444   -17649.444    275.99806    275.99806    43843.846    43843.846    2090.4841    2090.4841 
Loop time of 33.5444 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.576 ns/day, 9.318 hours/ns, 29.811 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    | 33.162     | 33.162     | 33.162     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061715   | 0.061715   | 0.061715   |   0.0 |  0.18
Output  | 7.3219e-05 | 7.3219e-05 | 7.3219e-05 |   0.0 |  0.00
Modify  | 0.27929    | 0.27929    | 0.27929    |   0.0 |  0.83
Other   |            | 0.04145    |            |       |  0.12

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:      889580.0 ave      889580 max      889580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889580
Ave neighs/atom = 222.39500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.927798625826, Press = -0.0987420103577575
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  106000   -17506.777   -17506.777   -17649.444   -17649.444    275.99806    275.99806    43843.846    43843.846    2090.4841    2090.4841 
  107000   -17511.905   -17511.905   -17652.343   -17652.343    271.68802    271.68802    43858.569    43858.569    1246.7682    1246.7682 
Loop time of 34.3203 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.517 ns/day, 9.533 hours/ns, 29.137 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    | 33.909     | 33.909     | 33.909     |   0.0 | 98.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064838   | 0.064838   | 0.064838   |   0.0 |  0.19
Output  | 0.00010796 | 0.00010796 | 0.00010796 |   0.0 |  0.00
Modify  | 0.29861    | 0.29861    | 0.29861    |   0.0 |  0.87
Other   |            | 0.04739    |            |       |  0.14

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:      889994.0 ave      889994 max      889994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889994
Ave neighs/atom = 222.49850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.943591541435, Press = 0.519456446805737
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  107000   -17511.905   -17511.905   -17652.343   -17652.343    271.68802    271.68802    43858.569    43858.569    1246.7682    1246.7682 
  108000   -17508.793   -17508.793   -17648.557   -17648.557    270.38357    270.38357    43900.497    43900.497   -174.74119   -174.74119 
Loop time of 33.8366 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.553 ns/day, 9.399 hours/ns, 29.554 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    | 33.441     | 33.441     | 33.441     |   0.0 | 98.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063311   | 0.063311   | 0.063311   |   0.0 |  0.19
Output  | 7.1572e-05 | 7.1572e-05 | 7.1572e-05 |   0.0 |  0.00
Modify  | 0.28709    | 0.28709    | 0.28709    |   0.0 |  0.85
Other   |            | 0.04468    |            |       |  0.13

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:      890028.0 ave      890028 max      890028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890028
Ave neighs/atom = 222.50700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.946498752099, Press = 0.511203499238305
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  108000   -17508.793   -17508.793   -17648.557   -17648.557    270.38357    270.38357    43900.497    43900.497   -174.74119   -174.74119 
  109000   -17514.413   -17514.413   -17656.895   -17656.895    275.63974    275.63974    43913.768    43913.768   -1113.2789   -1113.2789 
Loop time of 34.2767 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.521 ns/day, 9.521 hours/ns, 29.174 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    | 33.864     | 33.864     | 33.864     |   0.0 | 98.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064931   | 0.064931   | 0.064931   |   0.0 |  0.19
Output  | 0.00010957 | 0.00010957 | 0.00010957 |   0.0 |  0.00
Modify  | 0.2988     | 0.2988     | 0.2988     |   0.0 |  0.87
Other   |            | 0.04925    |            |       |  0.14

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:      889376.0 ave      889376 max      889376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889376
Ave neighs/atom = 222.34400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.940621903521, Press = 0.229711866160783
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  109000   -17514.413   -17514.413   -17656.895   -17656.895    275.63974    275.63974    43913.768    43913.768   -1113.2789   -1113.2789 
  110000   -17509.265   -17509.265   -17649.782   -17649.782    271.83796    271.83796    43901.657    43901.657   -222.68971   -222.68971 
Loop time of 34.3111 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.518 ns/day, 9.531 hours/ns, 29.145 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    | 33.901     | 33.901     | 33.901     |   0.0 | 98.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065014   | 0.065014   | 0.065014   |   0.0 |  0.19
Output  | 7.4142e-05 | 7.4142e-05 | 7.4142e-05 |   0.0 |  0.00
Modify  | 0.29737    | 0.29737    | 0.29737    |   0.0 |  0.87
Other   |            | 0.04778    |            |       |  0.14

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:      889760.0 ave      889760 max      889760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889760
Ave neighs/atom = 222.44000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.938396953684, Press = -0.148931505352588
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  110000   -17509.265   -17509.265   -17649.782   -17649.782    271.83796    271.83796    43901.657    43901.657   -222.68971   -222.68971 
  111000   -17511.421   -17511.421   -17651.801   -17651.801    271.57549    271.57549    43830.934    43830.934    2428.0776    2428.0776 
Loop time of 33.4246 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.585 ns/day, 9.285 hours/ns, 29.918 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    | 33.045     | 33.045     | 33.045     |   0.0 | 98.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061661   | 0.061661   | 0.061661   |   0.0 |  0.18
Output  | 0.00010358 | 0.00010358 | 0.00010358 |   0.0 |  0.00
Modify  | 0.27767    | 0.27767    | 0.27767    |   0.0 |  0.83
Other   |            | 0.0404     |            |       |  0.12

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:      889462.0 ave      889462 max      889462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889462
Ave neighs/atom = 222.36550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.939560213271, Press = -0.005254403611138
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  111000   -17511.421   -17511.421   -17651.801   -17651.801    271.57549    271.57549    43830.934    43830.934    2428.0776    2428.0776 
  112000   -17508.396   -17508.396   -17650.507   -17650.507    274.92315    274.92315    43844.694    43844.694     2020.599     2020.599 
Loop time of 33.7301 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.562 ns/day, 9.369 hours/ns, 29.647 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    | 33.338     | 33.338     | 33.338     |   0.0 | 98.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062757   | 0.062757   | 0.062757   |   0.0 |  0.19
Output  | 7.2374e-05 | 7.2374e-05 | 7.2374e-05 |   0.0 |  0.00
Modify  | 0.28518    | 0.28518    | 0.28518    |   0.0 |  0.85
Other   |            | 0.0437     |            |       |  0.13

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:      890378.0 ave      890378 max      890378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890378
Ave neighs/atom = 222.59450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.953405260173, Press = 0.667886177454923
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  112000   -17508.396   -17508.396   -17650.507   -17650.507    274.92315    274.92315    43844.694    43844.694     2020.599     2020.599 
  113000    -17509.33    -17509.33   -17650.492   -17650.492    273.08762    273.08762    43901.026    43901.026    -310.5335    -310.5335 
Loop time of 34.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.511 ns/day, 9.558 hours/ns, 29.062 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    | 33.998     | 33.998     | 33.998     |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065011   | 0.065011   | 0.065011   |   0.0 |  0.19
Output  | 0.00011696 | 0.00011696 | 0.00011696 |   0.0 |  0.00
Modify  | 0.29965    | 0.29965    | 0.29965    |   0.0 |  0.87
Other   |            | 0.04623    |            |       |  0.13

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:      890132.0 ave      890132 max      890132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 890132
Ave neighs/atom = 222.53300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.958596003437, Press = 0.566126627781776
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  113000    -17509.33    -17509.33   -17650.492   -17650.492    273.08762    273.08762    43901.026    43901.026    -310.5335    -310.5335 
  114000   -17511.214   -17511.214   -17654.338   -17654.338     276.8831     276.8831    43916.152    43916.152    -1118.569    -1118.569 
Loop time of 34.1931 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.527 ns/day, 9.498 hours/ns, 29.246 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    | 33.786     | 33.786     | 33.786     |   0.0 | 98.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064585   | 0.064585   | 0.064585   |   0.0 |  0.19
Output  | 7.4167e-05 | 7.4167e-05 | 7.4167e-05 |   0.0 |  0.00
Modify  | 0.29674    | 0.29674    | 0.29674    |   0.0 |  0.87
Other   |            | 0.04539    |            |       |  0.13

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:      889326.0 ave      889326 max      889326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889326
Ave neighs/atom = 222.33150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.980891016422, Press = 0.248621810182174
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.4
  ghost atom cutoff = 8.4
  binsize = 4.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.4
      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 
  114000   -17511.214   -17511.214   -17654.338   -17654.338     276.8831     276.8831    43916.152    43916.152    -1118.569    -1118.569 
  115000   -17506.563   -17506.563   -17650.123   -17650.123    277.72787    277.72787    43903.297    43903.297   -271.66627   -271.66627 
Loop time of 33.7969 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.556 ns/day, 9.388 hours/ns, 29.588 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    | 33.405     | 33.405     | 33.405     |   0.0 | 98.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063074   | 0.063074   | 0.063074   |   0.0 |  0.19
Output  | 9.8033e-05 | 9.8033e-05 | 9.8033e-05 |   0.0 |  0.00
Modify  | 0.28584    | 0.28584    | 0.28584    |   0.0 |  0.85
Other   |            | 0.04338    |            |       |  0.13

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:      889712.0 ave      889712 max      889712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 889712
Ave neighs/atom = 222.42800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
43892.0950893218

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0