# 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.8890872895717616*${_u_distance}
variable latticeconst_converted equal 3.8890872895717616*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.88908728957176
Lattice spacing in x,y,z = 3.8890873 3.8890873 3.8890873
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 (38.890873 38.890873 38.890873)
  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 (38.890873 38.890873 38.890873)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Pd

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

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


mass          1 ${mass_converted}
mass          1 106.42

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 58822.4450444068 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_008996216289_001#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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -15498.806   -15498.806       -15640       -15640       273.15       273.15    58822.445    58822.445    2563.8572    2563.8572 
    1000   -15358.613   -15358.613   -15499.149   -15499.149    271.87599    271.87599     59526.62     59526.62   -630.52822   -630.52822 
Loop time of 195.419 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.283 hours/ns, 5.117 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    | 194.45     | 194.45     | 194.45     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15418    | 0.15418    | 0.15418    |   0.0 |  0.08
Output  | 0.00022691 | 0.00022691 | 0.00022691 |   0.0 |  0.00
Modify  | 0.71824    | 0.71824    | 0.71824    |   0.0 |  0.37
Other   |            | 0.1001     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -15358.613   -15358.613   -15499.149   -15499.149    271.87599    271.87599     59526.62     59526.62   -630.52822   -630.52822 
    2000   -15361.482   -15361.482   -15501.463   -15501.463    270.80155    270.80155    59455.883    59455.883    1331.0019    1331.0019 
Loop time of 190.814 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.453 ns/day, 53.004 hours/ns, 5.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    | 189.93     | 189.93     | 189.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14585    | 0.14585    | 0.14585    |   0.0 |  0.08
Output  | 0.00021469 | 0.00021469 | 0.00021469 |   0.0 |  0.00
Modify  | 0.64338    | 0.64338    | 0.64338    |   0.0 |  0.34
Other   |            | 0.09557    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -15361.482   -15361.482   -15501.463   -15501.463    270.80155    270.80155    59455.883    59455.883    1331.0019    1331.0019 
    3000   -15365.649   -15365.649   -15503.333   -15503.333    266.35891    266.35891     59551.88     59551.88   -1897.5309   -1897.5309 
Loop time of 191.24 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.452 ns/day, 53.122 hours/ns, 5.229 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    | 190.35     | 190.35     | 190.35     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14447    | 0.14447    | 0.14447    |   0.0 |  0.08
Output  | 0.00021904 | 0.00021904 | 0.00021904 |   0.0 |  0.00
Modify  | 0.64366    | 0.64366    | 0.64366    |   0.0 |  0.34
Other   |            | 0.09663    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -15365.649   -15365.649   -15503.333   -15503.333    266.35891    266.35891     59551.88     59551.88   -1897.5309   -1897.5309 
    4000   -15357.776   -15357.776   -15503.221   -15503.221    281.37341    281.37341    59529.217    59529.217   -916.95599   -916.95599 
Loop time of 191.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.247 hours/ns, 5.217 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    | 190.8      | 190.8      | 190.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14736    | 0.14736    | 0.14736    |   0.0 |  0.08
Output  | 0.00021812 | 0.00021812 | 0.00021812 |   0.0 |  0.00
Modify  | 0.64412    | 0.64412    | 0.64412    |   0.0 |  0.34
Other   |            | 0.09352    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -15357.776   -15357.776   -15503.221   -15503.221    281.37341    281.37341    59529.217    59529.217   -916.95599   -916.95599 
    5000   -15364.683   -15364.683   -15508.087   -15508.087    277.42616    277.42616    59445.262    59445.262    1031.6995    1031.6995 
Loop time of 198.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.199 hours/ns, 5.032 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    | 197.79     | 197.79     | 197.79     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15185    | 0.15185    | 0.15185    |   0.0 |  0.08
Output  | 0.00024973 | 0.00024973 | 0.00024973 |   0.0 |  0.00
Modify  | 0.68005    | 0.68005    | 0.68005    |   0.0 |  0.34
Other   |            | 0.0971     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312024.0 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 267.730879517941, Press = -979.114836063621
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -15364.683   -15364.683   -15508.087   -15508.087    277.42616    277.42616    59445.262    59445.262    1031.6995    1031.6995 
    6000    -15360.94    -15360.94   -15502.954   -15502.954    274.73738    274.73738    59480.341    59480.341    518.01505    518.01505 
Loop time of 202.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.243 hours/ns, 4.939 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    | 201.5      | 201.5      | 201.5      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15379    | 0.15379    | 0.15379    |   0.0 |  0.08
Output  | 0.00018065 | 0.00018065 | 0.00018065 |   0.0 |  0.00
Modify  | 0.72019    | 0.72019    | 0.72019    |   0.0 |  0.36
Other   |            | 0.09874    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.010500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.121543532757, Press = -3.02375347046912
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    -15360.94    -15360.94   -15502.954   -15502.954    274.73738    274.73738    59480.341    59480.341    518.01505    518.01505 
    7000   -15362.909   -15362.909   -15502.534   -15502.534    270.11489    270.11489     59468.89     59468.89    914.25478    914.25478 
Loop time of 211.087 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.635 hours/ns, 4.737 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    | 210.07     | 210.07     | 210.07     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15801    | 0.15801    | 0.15801    |   0.0 |  0.07
Output  | 0.00018005 | 0.00018005 | 0.00018005 |   0.0 |  0.00
Modify  | 0.76085    | 0.76085    | 0.76085    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.904852409123, Press = -14.2648998598299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -15362.909   -15362.909   -15502.534   -15502.534    270.11489    270.11489     59468.89     59468.89    914.25478    914.25478 
    8000   -15367.213   -15367.213   -15505.773   -15505.773    268.05404    268.05404    59475.984    59475.984    227.46176    227.46176 
Loop time of 226.079 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.800 hours/ns, 4.423 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.96     | 224.96     | 224.96     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16884    | 0.16884    | 0.16884    |   0.0 |  0.07
Output  | 0.00027831 | 0.00027831 | 0.00027831 |   0.0 |  0.00
Modify  | 0.83705    | 0.83705    | 0.83705    |   0.0 |  0.37
Other   |            | 0.108      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312060.0 ave      312060 max      312060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312060
Ave neighs/atom = 78.015000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.142676108451, Press = -15.9253970183839
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -15367.213   -15367.213   -15505.773   -15505.773    268.05404    268.05404    59475.984    59475.984    227.46176    227.46176 
    9000   -15360.098   -15360.098   -15501.293   -15501.293    273.15148    273.15148    59524.679    59524.679   -686.46594   -686.46594 
Loop time of 224.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.248 hours/ns, 4.462 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    | 222.98     | 222.98     | 222.98     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16928    | 0.16928    | 0.16928    |   0.0 |  0.08
Output  | 0.0001845  | 0.0001845  | 0.0001845  |   0.0 |  0.00
Modify  | 0.83518    | 0.83518    | 0.83518    |   0.0 |  0.37
Other   |            | 0.1071     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312020.0 ave      312020 max      312020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312020
Ave neighs/atom = 78.005000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.839564548066, Press = -12.9231646028077
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -15360.098   -15360.098   -15501.293   -15501.293    273.15148    273.15148    59524.679    59524.679   -686.46594   -686.46594 
   10000   -15362.534   -15362.534   -15504.009   -15504.009    273.69289    273.69289    59476.619    59476.619    590.29849    590.29849 
Loop time of 224.801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.445 hours/ns, 4.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    | 223.69     | 223.69     | 223.69     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16777    | 0.16777    | 0.16777    |   0.0 |  0.07
Output  | 0.00021466 | 0.00021466 | 0.00021466 |   0.0 |  0.00
Modify  | 0.83523    | 0.83523    | 0.83523    |   0.0 |  0.37
Other   |            | 0.1075     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.35765624125, Press = -9.61099895780017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -15362.534   -15362.534   -15504.009   -15504.009    273.69289    273.69289    59476.619    59476.619    590.29849    590.29849 
   11000   -15358.117   -15358.117   -15502.265   -15502.265    278.86436    278.86436    59538.166    59538.166   -1173.9802   -1173.9802 
Loop time of 225.823 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.728 hours/ns, 4.428 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.71     | 224.71     | 224.71     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16742    | 0.16742    | 0.16742    |   0.0 |  0.07
Output  | 0.00029363 | 0.00029363 | 0.00029363 |   0.0 |  0.00
Modify  | 0.83668    | 0.83668    | 0.83668    |   0.0 |  0.37
Other   |            | 0.1088     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.390448327048, Press = 1.01235516615067
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -15358.117   -15358.117   -15502.265   -15502.265    278.86436    278.86436    59538.166    59538.166   -1173.9802   -1173.9802 
   12000   -15363.052   -15363.052   -15504.779   -15504.779    274.17959    274.17959    59501.218    59501.218    -343.9868    -343.9868 
Loop time of 223.617 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.116 hours/ns, 4.472 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    | 222.51     | 222.51     | 222.51     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16694    | 0.16694    | 0.16694    |   0.0 |  0.07
Output  | 0.00019205 | 0.00019205 | 0.00019205 |   0.0 |  0.00
Modify  | 0.82871    | 0.82871    | 0.82871    |   0.0 |  0.37
Other   |            | 0.1079     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312022.0 ave      312022 max      312022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312022
Ave neighs/atom = 78.005500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.268923623301, Press = -9.11835654616029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -15363.052   -15363.052   -15504.779   -15504.779    274.17959    274.17959    59501.218    59501.218    -343.9868    -343.9868 
   13000    -15362.61    -15362.61   -15502.453   -15502.453    270.53664    270.53664     59477.44     59477.44    645.10763    645.10763 
Loop time of 223.769 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.158 hours/ns, 4.469 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.67     | 222.67     | 222.67     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16678    | 0.16678    | 0.16678    |   0.0 |  0.07
Output  | 0.00022084 | 0.00022084 | 0.00022084 |   0.0 |  0.00
Modify  | 0.826      | 0.826      | 0.826      |   0.0 |  0.37
Other   |            | 0.1058     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312032.0 ave      312032 max      312032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312032
Ave neighs/atom = 78.008000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.259639477235, Press = -0.553481405095269
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -15362.61    -15362.61   -15502.453   -15502.453    270.53664    270.53664     59477.44     59477.44    645.10763    645.10763 
   14000   -15355.874   -15355.874   -15499.251   -15499.251    277.37323    277.37323    59529.656    59529.656   -554.77074   -554.77074 
Loop time of 221.223 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.451 hours/ns, 4.520 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    | 220.14     | 220.14     | 220.14     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16417    | 0.16417    | 0.16417    |   0.0 |  0.07
Output  | 0.00018112 | 0.00018112 | 0.00018112 |   0.0 |  0.00
Modify  | 0.81445    | 0.81445    | 0.81445    |   0.0 |  0.37
Other   |            | 0.1046     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.010500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.239818388028, Press = -4.36911873851021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -15355.874   -15355.874   -15499.251   -15499.251    277.37323    277.37323    59529.656    59529.656   -554.77074   -554.77074 
   15000   -15364.026   -15364.026    -15504.16    -15504.16    271.09882    271.09882    59494.137    59494.137   -94.654287   -94.654287 
Loop time of 219.217 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.894 hours/ns, 4.562 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 218.15     | 218.15     | 218.15     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1638     | 0.1638     | 0.1638     |   0.0 |  0.07
Output  | 0.00047011 | 0.00047011 | 0.00047011 |   0.0 |  0.00
Modify  | 0.80056    | 0.80056    | 0.80056    |   0.0 |  0.37
Other   |            | 0.1057     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312056.0 ave      312056 max      312056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312056
Ave neighs/atom = 78.014000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.306874267759, Press = -2.18925341622877
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -15364.026   -15364.026    -15504.16    -15504.16    271.09882    271.09882    59494.137    59494.137   -94.654287   -94.654287 
   16000   -15359.571   -15359.571   -15501.013   -15501.013    273.62864    273.62864    59545.356    59545.356    -1237.673    -1237.673 
Loop time of 202.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.151 hours/ns, 4.947 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    | 201.17     | 201.17     | 201.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15098    | 0.15098    | 0.15098    |   0.0 |  0.07
Output  | 0.0001792  | 0.0001792  | 0.0001792  |   0.0 |  0.00
Modify  | 0.72232    | 0.72232    | 0.72232    |   0.0 |  0.36
Other   |            | 0.101      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312030.0 ave      312030 max      312030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312030
Ave neighs/atom = 78.007500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.475644902887, Press = -4.3886458460142
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -15359.571   -15359.571   -15501.013   -15501.013    273.62864    273.62864    59545.356    59545.356    -1237.673    -1237.673 
   17000   -15364.164   -15364.164   -15504.619   -15504.619    271.71993    271.71993    59482.956    59482.956    242.01153    242.01153 
Loop time of 201.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 56.008 hours/ns, 4.960 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    | 200.66     | 200.66     | 200.66     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15096    | 0.15096    | 0.15096    |   0.0 |  0.07
Output  | 0.00018194 | 0.00018194 | 0.00018194 |   0.0 |  0.00
Modify  | 0.71859    | 0.71859    | 0.71859    |   0.0 |  0.36
Other   |            | 0.1014     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.41716628725, Press = -0.636271782094294
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -15364.164   -15364.164   -15504.619   -15504.619    271.71993    271.71993    59482.956    59482.956    242.01153    242.01153 
   18000   -15361.023   -15361.023   -15503.493   -15503.493     275.6183     275.6183    59531.852    59531.852   -1196.0859   -1196.0859 
Loop time of 205.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.199 hours/ns, 4.856 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    | 204.92     | 204.92     | 204.92     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15487    | 0.15487    | 0.15487    |   0.0 |  0.08
Output  | 0.0001788  | 0.0001788  | 0.0001788  |   0.0 |  0.00
Modify  | 0.7425     | 0.7425     | 0.7425     |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.510656791318, Press = -3.66957305933375
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -15361.023   -15361.023   -15503.493   -15503.493     275.6183     275.6183    59531.852    59531.852   -1196.0859   -1196.0859 
   19000   -15360.979   -15360.979   -15505.166   -15505.166    278.93954    278.93954    59440.388    59440.388    1654.4757    1654.4757 
Loop time of 212.532 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.407 ns/day, 59.037 hours/ns, 4.705 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 211.5      | 211.5      | 211.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16106    | 0.16106    | 0.16106    |   0.0 |  0.08
Output  | 0.00017786 | 0.00017786 | 0.00017786 |   0.0 |  0.00
Modify  | 0.77187    | 0.77187    | 0.77187    |   0.0 |  0.36
Other   |            | 0.1024     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.48199471946, Press = -2.1751518089743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -15360.979   -15360.979   -15505.166   -15505.166    278.93954    278.93954    59440.388    59440.388    1654.4757    1654.4757 
   20000   -15362.531   -15362.531   -15504.992   -15504.992    275.60142    275.60142    59527.517    59527.517   -1256.7982   -1256.7982 
Loop time of 215.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 59.995 hours/ns, 4.630 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    | 214.92     | 214.92     | 214.92     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16221    | 0.16221    | 0.16221    |   0.0 |  0.08
Output  | 0.0002409  | 0.0002409  | 0.0002409  |   0.0 |  0.00
Modify  | 0.79232    | 0.79232    | 0.79232    |   0.0 |  0.37
Other   |            | 0.1039     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.535492621265, Press = -1.23207474712271
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -15362.531   -15362.531   -15504.992   -15504.992    275.60142    275.60142    59527.517    59527.517   -1256.7982   -1256.7982 
   21000    -15358.83    -15358.83   -15503.602   -15503.602    280.07062    280.07062    59517.777    59517.777   -632.85948   -632.85948 
Loop time of 218.298 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.638 hours/ns, 4.581 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    | 217.22     | 217.22     | 217.22     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16399    | 0.16399    | 0.16399    |   0.0 |  0.08
Output  | 0.00018311 | 0.00018311 | 0.00018311 |   0.0 |  0.00
Modify  | 0.80665    | 0.80665    | 0.80665    |   0.0 |  0.37
Other   |            | 0.1043     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.502788942358, Press = -5.77452191296407
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    -15358.83    -15358.83   -15503.602   -15503.602    280.07062    280.07062    59517.777    59517.777   -632.85948   -632.85948 
   22000   -15363.174   -15363.174   -15504.744   -15504.744    273.87643    273.87643    59469.712    59469.712    727.64933    727.64933 
Loop time of 215.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 59.991 hours/ns, 4.630 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    | 214.91     | 214.91     | 214.91     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1612     | 0.1612     | 0.1612     |   0.0 |  0.07
Output  | 0.0002492  | 0.0002492  | 0.0002492  |   0.0 |  0.00
Modify  | 0.79451    | 0.79451    | 0.79451    |   0.0 |  0.37
Other   |            | 0.1034     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312038.0 ave      312038 max      312038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312038
Ave neighs/atom = 78.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.49766491185, Press = 0.125940021867781
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -15363.174   -15363.174   -15504.744   -15504.744    273.87643    273.87643    59469.712    59469.712    727.64933    727.64933 
   23000   -15368.412   -15368.412   -15505.667   -15505.667    265.53001    265.53001    59480.053    59480.053    123.63668    123.63668 
Loop time of 225.004 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.501 hours/ns, 4.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    | 223.89     | 223.89     | 223.89     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16764    | 0.16764    | 0.16764    |   0.0 |  0.07
Output  | 0.0002364  | 0.0002364  | 0.0002364  |   0.0 |  0.00
Modify  | 0.83965    | 0.83965    | 0.83965    |   0.0 |  0.37
Other   |            | 0.1064     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312028.0 ave      312028 max      312028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312028
Ave neighs/atom = 78.007000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.439972524913, Press = -3.03127152942551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -15368.412   -15368.412   -15505.667   -15505.667    265.53001    265.53001    59480.053    59480.053    123.63668    123.63668 
   24000   -15360.446   -15360.446   -15502.763   -15502.763    275.32196    275.32196    59481.945    59481.945    577.88948    577.88948 
Loop time of 224.922 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.478 hours/ns, 4.446 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    | 223.81     | 223.81     | 223.81     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16699    | 0.16699    | 0.16699    |   0.0 |  0.07
Output  | 0.00018074 | 0.00018074 | 0.00018074 |   0.0 |  0.00
Modify  | 0.83742    | 0.83742    | 0.83742    |   0.0 |  0.37
Other   |            | 0.1083     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.376425112188, Press = -1.90404533864985
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -15360.446   -15360.446   -15502.763   -15502.763    275.32196    275.32196    59481.945    59481.945    577.88948    577.88948 
   25000   -15366.721   -15366.721   -15505.336   -15505.336     268.1599     268.1599    59453.949    59453.949    1037.3886    1037.3886 
Loop time of 224.545 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.374 hours/ns, 4.453 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    | 223.43     | 223.43     | 223.43     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16898    | 0.16898    | 0.16898    |   0.0 |  0.08
Output  | 0.00018091 | 0.00018091 | 0.00018091 |   0.0 |  0.00
Modify  | 0.83758    | 0.83758    | 0.83758    |   0.0 |  0.37
Other   |            | 0.1086     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.28885145843, Press = -0.832268550099632
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -15366.721   -15366.721   -15505.336   -15505.336     268.1599     268.1599    59453.949    59453.949    1037.3886    1037.3886 
   26000   -15364.351   -15364.351    -15504.89    -15504.89     271.8836     271.8836    59525.344    59525.344   -1116.7938   -1116.7938 
Loop time of 224.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.436 hours/ns, 4.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    | 223.66     | 223.66     | 223.66     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16763    | 0.16763    | 0.16763    |   0.0 |  0.07
Output  | 0.00018011 | 0.00018011 | 0.00018011 |   0.0 |  0.00
Modify  | 0.83597    | 0.83597    | 0.83597    |   0.0 |  0.37
Other   |            | 0.1089     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312064.0 ave      312064 max      312064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312064
Ave neighs/atom = 78.016000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.254180028106, Press = -1.63471713230927
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -15364.351   -15364.351    -15504.89    -15504.89     271.8836     271.8836    59525.344    59525.344   -1116.7938   -1116.7938 
   27000   -15358.698   -15358.698   -15502.577   -15502.577    278.34453    278.34453    59469.323    59469.323    1075.7464    1075.7464 
Loop time of 206.568 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.380 hours/ns, 4.841 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.57     | 205.57     | 205.57     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15651    | 0.15651    | 0.15651    |   0.0 |  0.08
Output  | 0.00021555 | 0.00021555 | 0.00021555 |   0.0 |  0.00
Modify  | 0.73511    | 0.73511    | 0.73511    |   0.0 |  0.36
Other   |            | 0.1021     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.258766990437, Press = -2.01369985813455
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -15358.698   -15358.698   -15502.577   -15502.577    278.34453    278.34453    59469.323    59469.323    1075.7464    1075.7464 
   28000   -15362.807   -15362.807   -15504.298   -15504.298    273.72339    273.72339    59493.004    59493.004    76.739964    76.739964 
Loop time of 224.994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.498 hours/ns, 4.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    | 223.88     | 223.88     | 223.88     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1671     | 0.1671     | 0.1671     |   0.0 |  0.07
Output  | 0.00018456 | 0.00018456 | 0.00018456 |   0.0 |  0.00
Modify  | 0.84075    | 0.84075    | 0.84075    |   0.0 |  0.37
Other   |            | 0.1079     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.324870744552, Press = -0.297339311839179
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -15362.807   -15362.807   -15504.298   -15504.298    273.72339    273.72339    59493.004    59493.004    76.739964    76.739964 
   29000   -15357.763   -15357.763    -15500.58    -15500.58    276.28946    276.28946    59561.933    59561.933   -1719.2574   -1719.2574 
Loop time of 224.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.462 hours/ns, 4.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    | 223.75     | 223.75     | 223.75     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1667     | 0.1667     | 0.1667     |   0.0 |  0.07
Output  | 0.00018106 | 0.00018106 | 0.00018106 |   0.0 |  0.00
Modify  | 0.83835    | 0.83835    | 0.83835    |   0.0 |  0.37
Other   |            | 0.1081     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312030.0 ave      312030 max      312030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312030
Ave neighs/atom = 78.007500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.354204051963, Press = -1.31086258697973
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -15357.763   -15357.763    -15500.58    -15500.58    276.28946    276.28946    59561.933    59561.933   -1719.2574   -1719.2574 
   30000   -15361.716   -15361.716   -15503.325   -15503.325    273.95131    273.95131      59457.7      59457.7     1181.477     1181.477 
Loop time of 196.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.649 hours/ns, 5.083 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    | 195.8      | 195.8      | 195.8      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15066    | 0.15066    | 0.15066    |   0.0 |  0.08
Output  | 0.00022693 | 0.00022693 | 0.00022693 |   0.0 |  0.00
Modify  | 0.69403    | 0.69403    | 0.69403    |   0.0 |  0.35
Other   |            | 0.09529    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312026.0 ave      312026 max      312026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312026
Ave neighs/atom = 78.006500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.360477837931, Press = -1.56128732879755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -15361.716   -15361.716   -15503.325   -15503.325    273.95131    273.95131      59457.7      59457.7     1181.477     1181.477 
   31000   -15362.773   -15362.773   -15502.747   -15502.747    270.78865    270.78865    59526.683    59526.683   -918.20292   -918.20292 
Loop time of 191.36 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.452 ns/day, 53.156 hours/ns, 5.226 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    | 190.45     | 190.45     | 190.45     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1472     | 0.1472     | 0.1472     |   0.0 |  0.08
Output  | 0.00017933 | 0.00017933 | 0.00017933 |   0.0 |  0.00
Modify  | 0.66579    | 0.66579    | 0.66579    |   0.0 |  0.35
Other   |            | 0.09397    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312038.0 ave      312038 max      312038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312038
Ave neighs/atom = 78.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.346282699868, Press = -0.453210944432091
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -15362.773   -15362.773   -15502.747   -15502.747    270.78865    270.78865    59526.683    59526.683   -918.20292   -918.20292 
   32000   -15357.121   -15357.121   -15502.144   -15502.144    280.55601    280.55601    59507.461    59507.461    -186.9421    -186.9421 
Loop time of 191.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.249 hours/ns, 5.217 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    | 190.79     | 190.79     | 190.79     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14683    | 0.14683    | 0.14683    |   0.0 |  0.08
Output  | 0.00017923 | 0.00017923 | 0.00017923 |   0.0 |  0.00
Modify  | 0.6662     | 0.6662     | 0.6662     |   0.0 |  0.35
Other   |            | 0.0938     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312012.0 ave      312012 max      312012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312012
Ave neighs/atom = 78.003000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.342400687849, Press = -1.52599813130755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -15357.121   -15357.121   -15502.144   -15502.144    280.55601    280.55601    59507.461    59507.461    -186.9421    -186.9421 
   33000   -15364.045   -15364.045   -15505.619   -15505.619    273.88384    273.88384    59456.629    59456.629     937.1045     937.1045 
Loop time of 191.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.279 hours/ns, 5.214 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    | 190.9      | 190.9      | 190.9      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14659    | 0.14659    | 0.14659    |   0.0 |  0.08
Output  | 0.00023406 | 0.00023406 | 0.00023406 |   0.0 |  0.00
Modify  | 0.66601    | 0.66601    | 0.66601    |   0.0 |  0.35
Other   |            | 0.09354    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.407589759061, Press = -0.55164920611057
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -15364.045   -15364.045   -15505.619   -15505.619    273.88384    273.88384    59456.629    59456.629     937.1045     937.1045 
   34000   -15359.884   -15359.884   -15502.897   -15502.897    276.66801    276.66801    59514.591    59514.591   -425.21636   -425.21636 
Loop time of 191.599 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.222 hours/ns, 5.219 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    | 190.69     | 190.69     | 190.69     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14782    | 0.14782    | 0.14782    |   0.0 |  0.08
Output  | 0.00022138 | 0.00022138 | 0.00022138 |   0.0 |  0.00
Modify  | 0.66912    | 0.66912    | 0.66912    |   0.0 |  0.35
Other   |            | 0.09421    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.417295332003, Press = -1.81951727188918
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -15359.884   -15359.884   -15502.897   -15502.897    276.66801    276.66801    59514.591    59514.591   -425.21636   -425.21636 
   35000   -15362.882   -15362.882   -15504.075   -15504.075    273.14816    273.14816    59468.749    59468.749     809.2197     809.2197 
Loop time of 193.891 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.446 ns/day, 53.859 hours/ns, 5.158 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    | 192.97     | 192.97     | 192.97     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14801    | 0.14801    | 0.14801    |   0.0 |  0.08
Output  | 0.00018021 | 0.00018021 | 0.00018021 |   0.0 |  0.00
Modify  | 0.68106    | 0.68106    | 0.68106    |   0.0 |  0.35
Other   |            | 0.09488    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.419817140379, Press = -1.11999317535822
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -15362.882   -15362.882   -15504.075   -15504.075    273.14816    273.14816    59468.749    59468.749     809.2197     809.2197 
   36000    -15362.63    -15362.63   -15504.609   -15504.609     274.6677     274.6677    59508.012    59508.012   -501.03795   -501.03795 
Loop time of 208.289 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.858 hours/ns, 4.801 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 207.28     | 207.28     | 207.28     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15603    | 0.15603    | 0.15603    |   0.0 |  0.07
Output  | 0.0001834  | 0.0001834  | 0.0001834  |   0.0 |  0.00
Modify  | 0.74928    | 0.74928    | 0.74928    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.467042940324, Press = -1.52912850965552
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -15362.63    -15362.63   -15504.609   -15504.609     274.6677     274.6677    59508.012    59508.012   -501.03795   -501.03795 
   37000   -15360.771   -15360.771   -15502.258   -15502.258    273.71581    273.71581    59506.264    59506.264   -153.99747   -153.99747 
Loop time of 224.823 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.451 hours/ns, 4.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    | 223.71     | 223.71     | 223.71     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16614    | 0.16614    | 0.16614    |   0.0 |  0.07
Output  | 0.0002788  | 0.0002788  | 0.0002788  |   0.0 |  0.00
Modify  | 0.83508    | 0.83508    | 0.83508    |   0.0 |  0.37
Other   |            | 0.1076     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312026.0 ave      312026 max      312026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312026
Ave neighs/atom = 78.006500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.477123232302, Press = -0.751282175268183
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -15360.771   -15360.771   -15502.258   -15502.258    273.71581    273.71581    59506.264    59506.264   -153.99747   -153.99747 
   38000   -15362.202   -15362.202   -15504.512   -15504.512    275.30889    275.30889    59510.768    59510.768   -534.81936   -534.81936 
Loop time of 224.065 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.240 hours/ns, 4.463 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.96     | 222.96     | 222.96     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1653     | 0.1653     | 0.1653     |   0.0 |  0.07
Output  | 0.00018048 | 0.00018048 | 0.00018048 |   0.0 |  0.00
Modify  | 0.82813    | 0.82813    | 0.82813    |   0.0 |  0.37
Other   |            | 0.1066     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312020.0 ave      312020 max      312020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312020
Ave neighs/atom = 78.005000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.512582386845, Press = -1.02054225379599
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -15362.202   -15362.202   -15504.512   -15504.512    275.30889    275.30889    59510.768    59510.768   -534.81936   -534.81936 
   39000   -15358.768   -15358.768   -15502.431   -15502.431    277.92502    277.92502    59493.315    59493.315    191.57632    191.57632 
Loop time of 220.605 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.279 hours/ns, 4.533 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    | 219.52     | 219.52     | 219.52     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16285    | 0.16285    | 0.16285    |   0.0 |  0.07
Output  | 0.00017944 | 0.00017944 | 0.00017944 |   0.0 |  0.00
Modify  | 0.81566    | 0.81566    | 0.81566    |   0.0 |  0.37
Other   |            | 0.1073     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312028.0 ave      312028 max      312028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312028
Ave neighs/atom = 78.007000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.50938292305, Press = -1.34222925812076
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -15358.768   -15358.768   -15502.431   -15502.431    277.92502    277.92502    59493.315    59493.315    191.57632    191.57632 
   40000   -15364.915   -15364.915   -15505.272   -15505.272     271.5302     271.5302    59452.735    59452.735    1144.5474    1144.5474 
Loop time of 216.87 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.242 hours/ns, 4.611 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    | 215.8      | 215.8      | 215.8      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16124    | 0.16124    | 0.16124    |   0.0 |  0.07
Output  | 0.00022049 | 0.00022049 | 0.00022049 |   0.0 |  0.00
Modify  | 0.79873    | 0.79873    | 0.79873    |   0.0 |  0.37
Other   |            | 0.1061     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.010500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.512593568392, Press = -0.960375819272275
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -15364.915   -15364.915   -15505.272   -15505.272     271.5302     271.5302    59452.735    59452.735    1144.5474    1144.5474 
   41000   -15359.442   -15359.442   -15501.969   -15501.969    275.72796    275.72796    59589.285    59589.285   -2893.7351   -2893.7351 
Loop time of 225.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.574 hours/ns, 4.439 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    | 224.15     | 224.15     | 224.15     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16809    | 0.16809    | 0.16809    |   0.0 |  0.07
Output  | 0.001455   | 0.001455   | 0.001455   |   0.0 |  0.00
Modify  | 0.83936    | 0.83936    | 0.83936    |   0.0 |  0.37
Other   |            | 0.1077     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 78.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.536206622111, Press = -1.5975185964151
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -15359.442   -15359.442   -15501.969   -15501.969    275.72796    275.72796    59589.285    59589.285   -2893.7351   -2893.7351 
   42000   -15361.382   -15361.382   -15502.997   -15502.997    273.96274    273.96274    59492.883    59492.883    97.509257    97.509257 
Loop time of 224.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.402 hours/ns, 4.451 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.53     | 223.53     | 223.53     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16576    | 0.16576    | 0.16576    |   0.0 |  0.07
Output  | 0.00017874 | 0.00017874 | 0.00017874 |   0.0 |  0.00
Modify  | 0.84072    | 0.84072    | 0.84072    |   0.0 |  0.37
Other   |            | 0.1068     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.536833297212, Press = -0.767637699616812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -15361.382   -15361.382   -15502.997   -15502.997    273.96274    273.96274    59492.883    59492.883    97.509257    97.509257 
   43000   -15361.664   -15361.664   -15505.503   -15505.503    278.26693    278.26693    59515.771    59515.771   -918.99701   -918.99701 
Loop time of 220.026 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.118 hours/ns, 4.545 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    | 218.95     | 218.95     | 218.95     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1624     | 0.1624     | 0.1624     |   0.0 |  0.07
Output  | 0.00022674 | 0.00022674 | 0.00022674 |   0.0 |  0.00
Modify  | 0.81119    | 0.81119    | 0.81119    |   0.0 |  0.37
Other   |            | 0.105      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.583330512498, Press = -1.19682594807827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -15361.664   -15361.664   -15505.503   -15505.503    278.26693    278.26693    59515.771    59515.771   -918.99701   -918.99701 
   44000   -15359.553   -15359.553   -15502.652   -15502.652    276.83554    276.83554    59462.227    59462.227    1233.9556    1233.9556 
Loop time of 224.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.408 hours/ns, 4.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    | 223.56     | 223.56     | 223.56     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1659     | 0.1659     | 0.1659     |   0.0 |  0.07
Output  | 0.00024824 | 0.00024824 | 0.00024824 |   0.0 |  0.00
Modify  | 0.83323    | 0.83323    | 0.83323    |   0.0 |  0.37
Other   |            | 0.1067     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.586232296502, Press = -0.190191660321923
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -15359.553   -15359.553   -15502.652   -15502.652    276.83554    276.83554    59462.227    59462.227    1233.9556    1233.9556 
   45000   -15362.914   -15362.914   -15504.496   -15504.496    273.90065    273.90065    59519.169    59519.169   -973.23553   -973.23553 
Loop time of 225.294 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.582 hours/ns, 4.439 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    | 224.19     | 224.19     | 224.19     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16489    | 0.16489    | 0.16489    |   0.0 |  0.07
Output  | 0.00017815 | 0.00017815 | 0.00017815 |   0.0 |  0.00
Modify  | 0.82779    | 0.82779    | 0.82779    |   0.0 |  0.37
Other   |            | 0.1074     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.565663952947, Press = -1.7551795776629
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -15362.914   -15362.914   -15504.496   -15504.496    273.90065    273.90065    59519.169    59519.169   -973.23553   -973.23553 
   46000   -15355.157   -15355.157   -15500.896   -15500.896    281.94243    281.94243    59496.087    59496.087    394.26091    394.26091 
Loop time of 224.731 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.425 hours/ns, 4.450 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.62     | 223.62     | 223.62     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16552    | 0.16552    | 0.16552    |   0.0 |  0.07
Output  | 0.00017903 | 0.00017903 | 0.00017903 |   0.0 |  0.00
Modify  | 0.83538    | 0.83538    | 0.83538    |   0.0 |  0.37
Other   |            | 0.1069     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312030.0 ave      312030 max      312030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312030
Ave neighs/atom = 78.007500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.568507712039, Press = -0.494811441148659
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -15355.157   -15355.157   -15500.896   -15500.896    281.94243    281.94243    59496.087    59496.087    394.26091    394.26091 
   47000   -15364.953   -15364.953   -15505.351   -15505.351    271.60852    271.60852    59514.227    59514.227   -761.15895   -761.15895 
Loop time of 213.118 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.200 hours/ns, 4.692 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    | 212.08     | 212.08     | 212.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15977    | 0.15977    | 0.15977    |   0.0 |  0.07
Output  | 0.0001822  | 0.0001822  | 0.0001822  |   0.0 |  0.00
Modify  | 0.77452    | 0.77452    | 0.77452    |   0.0 |  0.36
Other   |            | 0.1029     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.590626961771, Press = -0.744581419263106
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -15364.953   -15364.953   -15505.351   -15505.351    271.60852    271.60852    59514.227    59514.227   -761.15895   -761.15895 
   48000   -15363.812   -15363.812    -15503.66    -15503.66    270.54477    270.54477    59467.592    59467.592    889.50416    889.50416 
Loop time of 221.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.408 hours/ns, 4.524 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    | 219.98     | 219.98     | 219.98     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16566    | 0.16566    | 0.16566    |   0.0 |  0.07
Output  | 0.00024001 | 0.00024001 | 0.00024001 |   0.0 |  0.00
Modify  | 0.81879    | 0.81879    | 0.81879    |   0.0 |  0.37
Other   |            | 0.1076     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312014.0 ave      312014 max      312014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312014
Ave neighs/atom = 78.003500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.574127721697, Press = -0.945001694928186
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -15363.812   -15363.812    -15503.66    -15503.66    270.54477    270.54477    59467.592    59467.592    889.50416    889.50416 
   49000   -15363.959   -15363.959   -15504.043   -15504.043    271.00177    271.00177    59541.816    59541.816   -1602.0938   -1602.0938 
Loop time of 208.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.836 hours/ns, 4.803 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    | 207.2      | 207.2      | 207.2      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1558     | 0.1558     | 0.1558     |   0.0 |  0.07
Output  | 0.00024894 | 0.00024894 | 0.00024894 |   0.0 |  0.00
Modify  | 0.75445    | 0.75445    | 0.75445    |   0.0 |  0.36
Other   |            | 0.1022     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.511759805091, Press = 0.414537521036855
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -15363.959   -15363.959   -15504.043   -15504.043    271.00177    271.00177    59541.816    59541.816   -1602.0938   -1602.0938 
   50000   -15360.907   -15360.907   -15503.065   -15503.065    275.01479    275.01479    59503.679    59503.679   -231.16765   -231.16765 
Loop time of 225.077 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.521 hours/ns, 4.443 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    | 223.96     | 223.96     | 223.96     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16761    | 0.16761    | 0.16761    |   0.0 |  0.07
Output  | 0.00029476 | 0.00029476 | 0.00029476 |   0.0 |  0.00
Modify  | 0.8383     | 0.8383     | 0.8383     |   0.0 |  0.37
Other   |            | 0.108      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312028.0 ave      312028 max      312028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312028
Ave neighs/atom = 78.007000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.508704992717, Press = -1.78000001478314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -15360.907   -15360.907   -15503.065   -15503.065    275.01479    275.01479    59503.679    59503.679   -231.16765   -231.16765 
   51000   -15362.221   -15362.221   -15501.866   -15501.866    270.15266    270.15266     59474.72     59474.72    742.17563    742.17563 
Loop time of 224.897 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.471 hours/ns, 4.446 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    | 223.79     | 223.79     | 223.79     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16655    | 0.16655    | 0.16655    |   0.0 |  0.07
Output  | 0.00020151 | 0.00020151 | 0.00020151 |   0.0 |  0.00
Modify  | 0.83664    | 0.83664    | 0.83664    |   0.0 |  0.37
Other   |            | 0.1074     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312056.0 ave      312056 max      312056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312056
Ave neighs/atom = 78.014000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.502371860831, Press = 0.150674236482232
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -15362.221   -15362.221   -15501.866   -15501.866    270.15266    270.15266     59474.72     59474.72    742.17563    742.17563 
   52000   -15365.896   -15365.896   -15504.554   -15504.554    268.24371    268.24371    59552.888    59552.888   -2062.7331   -2062.7331 
Loop time of 219.092 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.859 hours/ns, 4.564 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    | 218.02     | 218.02     | 218.02     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16247    | 0.16247    | 0.16247    |   0.0 |  0.07
Output  | 0.00018163 | 0.00018163 | 0.00018163 |   0.0 |  0.00
Modify  | 0.8029     | 0.8029     | 0.8029     |   0.0 |  0.37
Other   |            | 0.1047     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.505674091883, Press = -1.30274742184579
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -15365.896   -15365.896   -15504.554   -15504.554    268.24371    268.24371    59552.888    59552.888   -2062.7331   -2062.7331 
   53000   -15360.916   -15360.916   -15502.797   -15502.797    274.47781    274.47781    59502.517    59502.517   -209.20917   -209.20917 
Loop time of 224.705 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.418 hours/ns, 4.450 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    | 223.6      | 223.6      | 223.6      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16545    | 0.16545    | 0.16545    |   0.0 |  0.07
Output  | 0.0002     | 0.0002     | 0.0002     |   0.0 |  0.00
Modify  | 0.83459    | 0.83459    | 0.83459    |   0.0 |  0.37
Other   |            | 0.1087     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.49933634481, Press = 0.10525382434043
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -15360.916   -15360.916   -15502.797   -15502.797    274.47781    274.47781    59502.517    59502.517   -209.20917   -209.20917 
   54000   -15363.048   -15363.048   -15505.666   -15505.666    275.90331    275.90331    59512.739    59512.739   -629.60308   -629.60308 
Loop time of 225.704 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.695 hours/ns, 4.431 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.59     | 224.59     | 224.59     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1666     | 0.1666     | 0.1666     |   0.0 |  0.07
Output  | 0.00029026 | 0.00029026 | 0.00029026 |   0.0 |  0.00
Modify  | 0.83935    | 0.83935    | 0.83935    |   0.0 |  0.37
Other   |            | 0.108      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.512519737499, Press = -1.28609015785754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -15363.048   -15363.048   -15505.666   -15505.666    275.90331    275.90331    59512.739    59512.739   -629.60308   -629.60308 
   55000   -15360.332   -15360.332   -15504.908   -15504.908    279.69268    279.69268    59476.747    59476.747    459.83312    459.83312 
Loop time of 223.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 61.975 hours/ns, 4.482 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.01     | 222.01     | 222.01     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16487    | 0.16487    | 0.16487    |   0.0 |  0.07
Output  | 0.00027597 | 0.00027597 | 0.00027597 |   0.0 |  0.00
Modify  | 0.824      | 0.824      | 0.824      |   0.0 |  0.37
Other   |            | 0.1069     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.511194756112, Press = -0.86957768461975
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -15360.332   -15360.332   -15504.908   -15504.908    279.69268    279.69268    59476.747    59476.747    459.83312    459.83312 
   56000   -15363.266   -15363.266   -15501.105   -15501.105    266.65792    266.65792    59527.838    59527.838   -773.14291   -773.14291 
Loop time of 222.016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.671 hours/ns, 4.504 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    | 220.92     | 220.92     | 220.92     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16358    | 0.16358    | 0.16358    |   0.0 |  0.07
Output  | 0.00022103 | 0.00022103 | 0.00022103 |   0.0 |  0.00
Modify  | 0.82187    | 0.82187    | 0.82187    |   0.0 |  0.37
Other   |            | 0.1069     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312022.0 ave      312022 max      312022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312022
Ave neighs/atom = 78.005500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.507997472147, Press = -0.614032667305923
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -15363.266   -15363.266   -15501.105   -15501.105    266.65792    266.65792    59527.838    59527.838   -773.14291   -773.14291 
   57000   -15362.007   -15362.007   -15503.277   -15503.277    273.29707    273.29707    59479.606    59479.606    497.35525    497.35525 
Loop time of 225.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.591 hours/ns, 4.438 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.22     | 224.22     | 224.22     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16669    | 0.16669    | 0.16669    |   0.0 |  0.07
Output  | 0.00017888 | 0.00017888 | 0.00017888 |   0.0 |  0.00
Modify  | 0.83408    | 0.83408    | 0.83408    |   0.0 |  0.37
Other   |            | 0.1074     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312018.0 ave      312018 max      312018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312018
Ave neighs/atom = 78.004500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.513395490472, Press = -0.88920687088217
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -15362.007   -15362.007   -15503.277   -15503.277    273.29707    273.29707    59479.606    59479.606    497.35525    497.35525 
   58000   -15362.814   -15362.814   -15505.239   -15505.239    275.53093    275.53093    59485.425    59485.425    149.57869    149.57869 
Loop time of 225.19 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.553 hours/ns, 4.441 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.08     | 224.08     | 224.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16798    | 0.16798    | 0.16798    |   0.0 |  0.07
Output  | 0.00024683 | 0.00024683 | 0.00024683 |   0.0 |  0.00
Modify  | 0.83672    | 0.83672    | 0.83672    |   0.0 |  0.37
Other   |            | 0.1082     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312018.0 ave      312018 max      312018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312018
Ave neighs/atom = 78.004500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.516246390276, Press = -0.234870706191988
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -15362.814   -15362.814   -15505.239   -15505.239    275.53093    275.53093    59485.425    59485.425    149.57869    149.57869 
   59000   -15362.014   -15362.014   -15503.149   -15503.149    273.03598    273.03598    59473.692    59473.692    694.76993    694.76993 
Loop time of 209.923 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.312 hours/ns, 4.764 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 208.9      | 208.9      | 208.9      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15686    | 0.15686    | 0.15686    |   0.0 |  0.07
Output  | 0.00017847 | 0.00017847 | 0.00017847 |   0.0 |  0.00
Modify  | 0.75947    | 0.75947    | 0.75947    |   0.0 |  0.36
Other   |            | 0.1024     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.474172961118, Press = -1.48030489980692
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -15362.014   -15362.014   -15503.149   -15503.149    273.03598    273.03598    59473.692    59473.692    694.76993    694.76993 
   60000   -15364.596   -15364.596   -15505.815   -15505.815    273.19817    273.19817    59432.651    59432.651    1700.4972    1700.4972 
Loop time of 221.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.390 ns/day, 61.500 hours/ns, 4.517 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    | 220.31     | 220.31     | 220.31     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16433    | 0.16433    | 0.16433    |   0.0 |  0.07
Output  | 0.00022881 | 0.00022881 | 0.00022881 |   0.0 |  0.00
Modify  | 0.81955    | 0.81955    | 0.81955    |   0.0 |  0.37
Other   |            | 0.1063     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312020.0 ave      312020 max      312020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312020
Ave neighs/atom = 78.005000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.453286937044, Press = 0.0593853603387304
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -15364.596   -15364.596   -15505.815   -15505.815    273.19817    273.19817    59432.651    59432.651    1700.4972    1700.4972 
   61000   -15355.397   -15355.397   -15500.285   -15500.285    280.29445    280.29445    59616.958    59616.958   -3496.2162   -3496.2162 
Loop time of 224.684 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.412 hours/ns, 4.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    | 223.59     | 223.59     | 223.59     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16536    | 0.16536    | 0.16536    |   0.0 |  0.07
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.82416    | 0.82416    | 0.82416    |   0.0 |  0.37
Other   |            | 0.1071     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.468846959284, Press = -0.696661289567254
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -15355.397   -15355.397   -15500.285   -15500.285    280.29445    280.29445    59616.958    59616.958   -3496.2162   -3496.2162 
   62000   -15363.372   -15363.372   -15505.717   -15505.717    275.37744    275.37744    59468.562    59468.562    658.54819    658.54819 
Loop time of 224.518 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.366 hours/ns, 4.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    | 223.41     | 223.41     | 223.41     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16548    | 0.16548    | 0.16548    |   0.0 |  0.07
Output  | 0.00023338 | 0.00023338 | 0.00023338 |   0.0 |  0.00
Modify  | 0.83571    | 0.83571    | 0.83571    |   0.0 |  0.37
Other   |            | 0.1078     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312008.0 ave      312008 max      312008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312008
Ave neighs/atom = 78.002000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.479007547006, Press = -0.423119846799613
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -15363.372   -15363.372   -15505.717   -15505.717    275.37744    275.37744    59468.562    59468.562    658.54819    658.54819 
   63000   -15361.139   -15361.139   -15501.696   -15501.696    271.91693    271.91693    59536.688    59536.688   -1185.2322   -1185.2322 
Loop time of 219.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.878 hours/ns, 4.563 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    | 218.08     | 218.08     | 218.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16428    | 0.16428    | 0.16428    |   0.0 |  0.07
Output  | 0.00018879 | 0.00018879 | 0.00018879 |   0.0 |  0.00
Modify  | 0.8116     | 0.8116     | 0.8116     |   0.0 |  0.37
Other   |            | 0.1066     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312038.0 ave      312038 max      312038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312038
Ave neighs/atom = 78.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.496125246751, Press = -0.535020011260016
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -15361.139   -15361.139   -15501.696   -15501.696    271.91693    271.91693    59536.688    59536.688   -1185.2322   -1185.2322 
   64000   -15362.717   -15362.717   -15504.236   -15504.236    273.77776    273.77776    59476.901    59476.901    440.66067    440.66067 
Loop time of 218.297 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.638 hours/ns, 4.581 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    | 217.23     | 217.23     | 217.23     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16334    | 0.16334    | 0.16334    |   0.0 |  0.07
Output  | 0.00022685 | 0.00022685 | 0.00022685 |   0.0 |  0.00
Modify  | 0.80101    | 0.80101    | 0.80101    |   0.0 |  0.37
Other   |            | 0.1048     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312042.0 ave      312042 max      312042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312042
Ave neighs/atom = 78.010500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.50921788167, Press = -0.990691289776784
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -15362.717   -15362.717   -15504.236   -15504.236    273.77776    273.77776    59476.901    59476.901    440.66067    440.66067 
   65000   -15363.411   -15363.411   -15506.241   -15506.241    276.31574    276.31574     59510.51     59510.51   -830.55106   -830.55106 
Loop time of 214.537 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.403 ns/day, 59.594 hours/ns, 4.661 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    | 213.49     | 213.49     | 213.49     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16022    | 0.16022    | 0.16022    |   0.0 |  0.07
Output  | 0.00022693 | 0.00022693 | 0.00022693 |   0.0 |  0.00
Modify  | 0.78652    | 0.78652    | 0.78652    |   0.0 |  0.37
Other   |            | 0.105      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312020.0 ave      312020 max      312020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312020
Ave neighs/atom = 78.005000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.528402543923, Press = 0.0920012628392402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -15363.411   -15363.411   -15506.241   -15506.241    276.31574    276.31574     59510.51     59510.51   -830.55106   -830.55106 
   66000   -15360.855   -15360.855   -15504.351   -15504.351     277.6022     277.6022     59470.33     59470.33    612.56707    612.56707 
Loop time of 219.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.944 hours/ns, 4.558 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 218.33     | 218.33     | 218.33     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16436    | 0.16436    | 0.16436    |   0.0 |  0.07
Output  | 0.00018217 | 0.00018217 | 0.00018217 |   0.0 |  0.00
Modify  | 0.80434    | 0.80434    | 0.80434    |   0.0 |  0.37
Other   |            | 0.1044     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.517818198343, Press = -0.813746052435084
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -15360.855   -15360.855   -15504.351   -15504.351     277.6022     277.6022     59470.33     59470.33    612.56707    612.56707 
   67000    -15367.38    -15367.38   -15505.808   -15505.808    267.79808    267.79808    59460.544    59460.544    603.34922    603.34922 
Loop time of 219.596 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 60.999 hours/ns, 4.554 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    | 218.51     | 218.51     | 218.51     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16512    | 0.16512    | 0.16512    |   0.0 |  0.08
Output  | 0.00055639 | 0.00055639 | 0.00055639 |   0.0 |  0.00
Modify  | 0.81028    | 0.81028    | 0.81028    |   0.0 |  0.37
Other   |            | 0.106      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312024.0 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.493792455044, Press = -0.201673728252146
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000    -15367.38    -15367.38   -15505.808   -15505.808    267.79808    267.79808    59460.544    59460.544    603.34922    603.34922 
   68000   -15360.861   -15360.861   -15504.284   -15504.284    277.46164    277.46164    59521.903    59521.903   -927.23104   -927.23104 
Loop time of 224.794 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.443 hours/ns, 4.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    | 223.68     | 223.68     | 223.68     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1693     | 0.1693     | 0.1693     |   0.0 |  0.08
Output  | 0.00018051 | 0.00018051 | 0.00018051 |   0.0 |  0.00
Modify  | 0.83885    | 0.83885    | 0.83885    |   0.0 |  0.37
Other   |            | 0.1082     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312038.0 ave      312038 max      312038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312038
Ave neighs/atom = 78.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.483487420472, Press = -1.10704900165644
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -15360.861   -15360.861   -15504.284   -15504.284    277.46164    277.46164    59521.903    59521.903   -927.23104   -927.23104 
   69000   -15361.007   -15361.007   -15502.619   -15502.619    273.95754    273.95754    59497.899    59497.899   -83.850875   -83.850875 
Loop time of 224.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.424 hours/ns, 4.450 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    | 223.61     | 223.61     | 223.61     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16937    | 0.16937    | 0.16937    |   0.0 |  0.08
Output  | 0.0001812  | 0.0001812  | 0.0001812  |   0.0 |  0.00
Modify  | 0.8425     | 0.8425     | 0.8425     |   0.0 |  0.37
Other   |            | 0.1089     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312030.0 ave      312030 max      312030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312030
Ave neighs/atom = 78.007500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.461417836481, Press = -0.0504271879435634
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -15361.007   -15361.007   -15502.619   -15502.619    273.95754    273.95754    59497.899    59497.899   -83.850875   -83.850875 
   70000    -15365.47    -15365.47   -15505.123   -15505.123    270.16847    270.16847    59464.487    59464.487    779.12146    779.12146 
Loop time of 224.239 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.289 hours/ns, 4.460 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    | 223.12     | 223.12     | 223.12     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16675    | 0.16675    | 0.16675    |   0.0 |  0.07
Output  | 0.00024969 | 0.00024969 | 0.00024969 |   0.0 |  0.00
Modify  | 0.84112    | 0.84112    | 0.84112    |   0.0 |  0.38
Other   |            | 0.1084     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312036.0 ave      312036 max      312036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312036
Ave neighs/atom = 78.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.433447807363, Press = -1.16379660939384
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000    -15365.47    -15365.47   -15505.123   -15505.123    270.16847    270.16847    59464.487    59464.487    779.12146    779.12146 
   71000   -15363.068   -15363.068   -15502.111   -15502.111    268.98908    268.98908    59498.605    59498.605    74.876941    74.876941 
Loop time of 224.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.439 hours/ns, 4.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    | 223.66     | 223.66     | 223.66     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16866    | 0.16866    | 0.16866    |   0.0 |  0.08
Output  | 0.00022952 | 0.00022952 | 0.00022952 |   0.0 |  0.00
Modify  | 0.84517    | 0.84517    | 0.84517    |   0.0 |  0.38
Other   |            | 0.1098     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.448058473702, Press = 0.117775178995246
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -15363.068   -15363.068   -15502.111   -15502.111    268.98908    268.98908    59498.605    59498.605    74.876941    74.876941 
   72000     -15361.3     -15361.3    -15500.64    -15500.64    269.56199    269.56199     59492.42     59492.42    420.30093    420.30093 
Loop time of 203.89 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.636 hours/ns, 4.905 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    | 202.91     | 202.91     | 202.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15396    | 0.15396    | 0.15396    |   0.0 |  0.08
Output  | 0.00018037 | 0.00018037 | 0.00018037 |   0.0 |  0.00
Modify  | 0.72828    | 0.72828    | 0.72828    |   0.0 |  0.36
Other   |            | 0.102      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.448768395195, Press = -0.460233419602649
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000     -15361.3     -15361.3    -15500.64    -15500.64    269.56199    269.56199     59492.42     59492.42    420.30093    420.30093 
   73000   -15365.304   -15365.304   -15505.524   -15505.524    271.26368    271.26368    59502.957    59502.957   -484.58561   -484.58561 
Loop time of 222.23 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.731 hours/ns, 4.500 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    | 221.13     | 221.13     | 221.13     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16668    | 0.16668    | 0.16668    |   0.0 |  0.08
Output  | 0.00027842 | 0.00027842 | 0.00027842 |   0.0 |  0.00
Modify  | 0.82474    | 0.82474    | 0.82474    |   0.0 |  0.37
Other   |            | 0.1071     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312074.0 ave      312074 max      312074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312074
Ave neighs/atom = 78.018500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.437359257603, Press = -0.490535045535535
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -15365.304   -15365.304   -15505.524   -15505.524    271.26368    271.26368    59502.957    59502.957   -484.58561   -484.58561 
   74000   -15359.215   -15359.215   -15502.378   -15502.378    276.95998    276.95998    59459.845    59459.845    1262.1113    1262.1113 
Loop time of 225.144 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.540 hours/ns, 4.442 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.03     | 224.03     | 224.03     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16822    | 0.16822    | 0.16822    |   0.0 |  0.07
Output  | 0.00017858 | 0.00017858 | 0.00017858 |   0.0 |  0.00
Modify  | 0.83978    | 0.83978    | 0.83978    |   0.0 |  0.37
Other   |            | 0.1084     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312024.0 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 78.006000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.418998029299, Press = -0.154011361518341
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -15359.215   -15359.215   -15502.378   -15502.378    276.95998    276.95998    59459.845    59459.845    1262.1113    1262.1113 
   75000   -15364.521   -15364.521   -15500.218   -15500.218    262.51634    262.51634    59584.746    59584.746   -2602.5159   -2602.5159 
Loop time of 224.511 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.364 hours/ns, 4.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    | 223.4      | 223.4      | 223.4      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16833    | 0.16833    | 0.16833    |   0.0 |  0.07
Output  | 0.00018159 | 0.00018159 | 0.00018159 |   0.0 |  0.00
Modify  | 0.83478    | 0.83478    | 0.83478    |   0.0 |  0.37
Other   |            | 0.1081     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312056.0 ave      312056 max      312056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312056
Ave neighs/atom = 78.014000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.423464973888, Press = -0.328787548135555
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -15364.521   -15364.521   -15500.218   -15500.218    262.51634    262.51634    59584.746    59584.746   -2602.5159   -2602.5159 
   76000   -15360.421   -15360.421   -15503.724   -15503.724    277.22952    277.22952    59482.162    59482.162     477.5257     477.5257 
Loop time of 224.364 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.323 hours/ns, 4.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    | 223.26     | 223.26     | 223.26     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16691    | 0.16691    | 0.16691    |   0.0 |  0.07
Output  | 0.00022613 | 0.00022613 | 0.00022613 |   0.0 |  0.00
Modify  | 0.83189    | 0.83189    | 0.83189    |   0.0 |  0.37
Other   |            | 0.1063     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312048.0 ave      312048 max      312048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.412662436961, Press = -1.07151914468577
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -15360.421   -15360.421   -15503.724   -15503.724    277.22952    277.22952    59482.162    59482.162     477.5257     477.5257 
   77000    -15365.86    -15365.86   -15505.627   -15505.627     270.3876     270.3876    59483.369    59483.369     122.5126     122.5126 
Loop time of 191.978 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.327 hours/ns, 5.209 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    | 191.07     | 191.07     | 191.07     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14891    | 0.14891    | 0.14891    |   0.0 |  0.08
Output  | 0.00018082 | 0.00018082 | 0.00018082 |   0.0 |  0.00
Modify  | 0.66813    | 0.66813    | 0.66813    |   0.0 |  0.35
Other   |            | 0.09417    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 78.013500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.397129434286, Press = -0.166111967372062
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000    -15365.86    -15365.86   -15505.627   -15505.627     270.3876     270.3876    59483.369    59483.369     122.5126     122.5126 
   78000   -15362.046   -15362.046   -15503.022   -15503.022    272.72893    272.72893    59535.296    59535.296   -1246.1658   -1246.1658 
Loop time of 191.657 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.238 hours/ns, 5.218 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    | 190.74     | 190.74     | 190.74     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14968    | 0.14968    | 0.14968    |   0.0 |  0.08
Output  | 0.00018215 | 0.00018215 | 0.00018215 |   0.0 |  0.00
Modify  | 0.66922    | 0.66922    | 0.66922    |   0.0 |  0.35
Other   |            | 0.09422    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.392644389216, Press = -0.765763037435004
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -15362.046   -15362.046   -15503.022   -15503.022    272.72893    272.72893    59535.296    59535.296   -1246.1658   -1246.1658 
   79000   -15359.737   -15359.737   -15501.319   -15501.319    273.89892    273.89892    59431.275    59431.275    2312.6473    2312.6473 
Loop time of 191.464 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.184 hours/ns, 5.223 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    | 190.55     | 190.55     | 190.55     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14788    | 0.14788    | 0.14788    |   0.0 |  0.08
Output  | 0.00018324 | 0.00018324 | 0.00018324 |   0.0 |  0.00
Modify  | 0.66909    | 0.66909    | 0.66909    |   0.0 |  0.35
Other   |            | 0.09481    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312038.0 ave      312038 max      312038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312038
Ave neighs/atom = 78.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.372542479189, Press = -0.102779573753703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -15359.737   -15359.737   -15501.319   -15501.319    273.89892    273.89892    59431.275    59431.275    2312.6473    2312.6473 
   80000    -15366.41    -15366.41   -15503.689   -15503.689    265.57387    265.57387    59511.907    59511.907    -703.5708    -703.5708 
Loop time of 191.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.325 hours/ns, 5.209 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    | 191.06     | 191.06     | 191.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14774    | 0.14774    | 0.14774    |   0.0 |  0.08
Output  | 0.00018283 | 0.00018283 | 0.00018283 |   0.0 |  0.00
Modify  | 0.66841    | 0.66841    | 0.66841    |   0.0 |  0.35
Other   |            | 0.09406    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312050.0 ave      312050 max      312050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312050
Ave neighs/atom = 78.012500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.368968682466, Press = -0.205632822495227
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000    -15366.41    -15366.41   -15503.689   -15503.689    265.57387    265.57387    59511.907    59511.907    -703.5708    -703.5708 
   81000   -15361.086   -15361.086   -15502.108   -15502.108    272.81791    272.81791     59513.79     59513.79   -402.40374   -402.40374 
Loop time of 191.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.237 hours/ns, 5.218 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    | 190.74     | 190.74     | 190.74     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14595    | 0.14595    | 0.14595    |   0.0 |  0.08
Output  | 0.00022955 | 0.00022955 | 0.00022955 |   0.0 |  0.00
Modify  | 0.66784    | 0.66784    | 0.66784    |   0.0 |  0.35
Other   |            | 0.09657    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312046.0 ave      312046 max      312046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312046
Ave neighs/atom = 78.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.349554615974, Press = -0.614389356067615
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -15361.086   -15361.086   -15502.108   -15502.108    272.81791    272.81791     59513.79     59513.79   -402.40374   -402.40374 
   82000   -15359.778   -15359.778    -15500.75    -15500.75    272.72155    272.72155    59464.749    59464.749    1344.2452    1344.2452 
Loop time of 191.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.452 ns/day, 53.120 hours/ns, 5.229 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    | 190.33     | 190.33     | 190.33     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14527    | 0.14527    | 0.14527    |   0.0 |  0.08
Output  | 0.00017866 | 0.00017866 | 0.00017866 |   0.0 |  0.00
Modify  | 0.66731    | 0.66731    | 0.66731    |   0.0 |  0.35
Other   |            | 0.09585    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312030.0 ave      312030 max      312030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312030
Ave neighs/atom = 78.007500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.32986313096, Press = -0.643569167537684
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -15359.778   -15359.778    -15500.75    -15500.75    272.72155    272.72155    59464.749    59464.749    1344.2452    1344.2452 
   83000   -15363.274   -15363.274   -15506.248   -15506.248    276.59337    276.59337     59455.32     59455.32    973.22882    973.22882 
Loop time of 191.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.255 hours/ns, 5.216 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    | 190.8      | 190.8      | 190.8      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14796    | 0.14796    | 0.14796    |   0.0 |  0.08
Output  | 0.00018033 | 0.00018033 | 0.00018033 |   0.0 |  0.00
Modify  | 0.67063    | 0.67063    | 0.67063    |   0.0 |  0.35
Other   |            | 0.09338    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312058.0 ave      312058 max      312058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312058
Ave neighs/atom = 78.014500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.329426221877, Press = -0.507117803551745
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -15363.274   -15363.274   -15506.248   -15506.248    276.59337    276.59337     59455.32     59455.32    973.22882    973.22882 
   84000   -15361.896   -15361.896   -15504.045   -15504.045      274.997      274.997    59562.828    59562.828   -2196.5223   -2196.5223 
Loop time of 192.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.449 ns/day, 53.444 hours/ns, 5.198 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    | 191.49     | 191.49     | 191.49     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14908    | 0.14908    | 0.14908    |   0.0 |  0.08
Output  | 0.00017839 | 0.00017839 | 0.00017839 |   0.0 |  0.00
Modify  | 0.66875    | 0.66875    | 0.66875    |   0.0 |  0.35
Other   |            | 0.09345    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312026.0 ave      312026 max      312026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312026
Ave neighs/atom = 78.006500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.344671354359, Press = -0.528723960401126
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -15361.896   -15361.896   -15504.045   -15504.045      274.997      274.997    59562.828    59562.828   -2196.5223   -2196.5223 
   85000   -15370.147   -15370.147   -15505.875   -15505.875    262.57543    262.57543    59442.891    59442.891    1280.5606    1280.5606 
Loop time of 191.572 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.214 hours/ns, 5.220 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    | 190.66     | 190.66     | 190.66     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14794    | 0.14794    | 0.14794    |   0.0 |  0.08
Output  | 0.00017867 | 0.00017867 | 0.00017867 |   0.0 |  0.00
Modify  | 0.66801    | 0.66801    | 0.66801    |   0.0 |  0.35
Other   |            | 0.09453    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312032.0 ave      312032 max      312032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312032
Ave neighs/atom = 78.008000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.322488043658, Press = -0.369659499902644
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -15370.147   -15370.147   -15505.875   -15505.875    262.57543    262.57543    59442.891    59442.891    1280.5606    1280.5606 
   86000   -15361.927   -15361.927   -15504.698   -15504.698    276.20042    276.20042    59514.889    59514.889   -740.90537   -740.90537 
Loop time of 191.686 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.246 hours/ns, 5.217 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    | 190.78     | 190.78     | 190.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14858    | 0.14858    | 0.14858    |   0.0 |  0.08
Output  | 0.00017846 | 0.00017846 | 0.00017846 |   0.0 |  0.00
Modify  | 0.667      | 0.667      | 0.667      |   0.0 |  0.35
Other   |            | 0.0938     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312040.0 ave      312040 max      312040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312040
Ave neighs/atom = 78.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.317914698938, Press = -0.428518313066938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -15361.927   -15361.927   -15504.698   -15504.698    276.20042    276.20042    59514.889    59514.889   -740.90537   -740.90537 
   87000   -15358.701   -15358.701   -15501.809   -15501.809    276.85326    276.85326    59460.107    59460.107    1321.7786    1321.7786 
Loop time of 192.118 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.366 hours/ns, 5.205 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    | 191.21     | 191.21     | 191.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14846    | 0.14846    | 0.14846    |   0.0 |  0.08
Output  | 0.00018005 | 0.00018005 | 0.00018005 |   0.0 |  0.00
Modify  | 0.66914    | 0.66914    | 0.66914    |   0.0 |  0.35
Other   |            | 0.09339    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312034.0 ave      312034 max      312034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.319968994129, Press = -0.619352737110476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -15358.701   -15358.701   -15501.809   -15501.809    276.85326    276.85326    59460.107    59460.107    1321.7786    1321.7786 
   88000   -15364.391   -15364.391   -15504.547   -15504.547    271.14216    271.14216    59516.095    59516.095   -858.96171   -858.96171 
Loop time of 191.772 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.270 hours/ns, 5.215 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    | 190.86     | 190.86     | 190.86     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14635    | 0.14635    | 0.14635    |   0.0 |  0.08
Output  | 0.00022279 | 0.00022279 | 0.00022279 |   0.0 |  0.00
Modify  | 0.66909    | 0.66909    | 0.66909    |   0.0 |  0.35
Other   |            | 0.09407    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 78.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
59495.2018191182

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0