# 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_PdCu__MO_353393547686_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_353393547686_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 190.658 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.453 ns/day, 52.961 hours/ns, 5.245 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    | 189.71     | 189.71     | 189.71     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14922    | 0.14922    | 0.14922    |   0.0 |  0.08
Output  | 0.00022693 | 0.00022693 | 0.00022693 |   0.0 |  0.00
Modify  | 0.6946     | 0.6946     | 0.6946     |   0.0 |  0.36
Other   |            | 0.09926    |            |       |  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 204.623 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.840 hours/ns, 4.887 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    | 203.66     | 203.66     | 203.66     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15338    | 0.15338    | 0.15338    |   0.0 |  0.07
Output  | 0.00028883 | 0.00028883 | 0.00028883 |   0.0 |  0.00
Modify  | 0.71033    | 0.71033    | 0.71033    |   0.0 |  0.35
Other   |            | 0.1018     |            |       |  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 204.999 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.944 hours/ns, 4.878 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.03     | 204.03     | 204.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15264    | 0.15264    | 0.15264    |   0.0 |  0.07
Output  | 0.00021618 | 0.00021618 | 0.00021618 |   0.0 |  0.00
Modify  | 0.71218    | 0.71218    | 0.71218    |   0.0 |  0.35
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 = 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 210.031 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.342 hours/ns, 4.761 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    | 209.03     | 209.03     | 209.03     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15782    | 0.15782    | 0.15782    |   0.0 |  0.08
Output  | 0.00021597 | 0.00021597 | 0.00021597 |   0.0 |  0.00
Modify  | 0.74274    | 0.74274    | 0.74274    |   0.0 |  0.35
Other   |            | 0.1037     |            |       |  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 210.877 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.577 hours/ns, 4.742 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    | 209.87     | 209.87     | 209.87     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15729    | 0.15729    | 0.15729    |   0.0 |  0.07
Output  | 0.00023576 | 0.00023576 | 0.00023576 |   0.0 |  0.00
Modify  | 0.74199    | 0.74199    | 0.74199    |   0.0 |  0.35
Other   |            | 0.1035     |            |       |  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 209.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.095 hours/ns, 4.781 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    | 208.12     | 208.12     | 208.12     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15746    | 0.15746    | 0.15746    |   0.0 |  0.08
Output  | 0.00030528 | 0.00030528 | 0.00030528 |   0.0 |  0.00
Modify  | 0.76211    | 0.76211    | 0.76211    |   0.0 |  0.36
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:      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 214.03 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.453 hours/ns, 4.672 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.99     | 212.99     | 212.99     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1598     | 0.1598     | 0.1598     |   0.0 |  0.07
Output  | 0.00022487 | 0.00022487 | 0.00022487 |   0.0 |  0.00
Modify  | 0.78026    | 0.78026    | 0.78026    |   0.0 |  0.36
Other   |            | 0.1036     |            |       |  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 209.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.208 hours/ns, 4.772 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 208.53     | 208.53     | 208.53     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15782    | 0.15782    | 0.15782    |   0.0 |  0.08
Output  | 0.00023046 | 0.00023046 | 0.00023046 |   0.0 |  0.00
Modify  | 0.75987    | 0.75987    | 0.75987    |   0.0 |  0.36
Other   |            | 0.1035     |            |       |  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 211.933 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.408 ns/day, 58.870 hours/ns, 4.718 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.91     | 210.91     | 210.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15748    | 0.15748    | 0.15748    |   0.0 |  0.07
Output  | 0.00018103 | 0.00018103 | 0.00018103 |   0.0 |  0.00
Modify  | 0.76453    | 0.76453    | 0.76453    |   0.0 |  0.36
Other   |            | 0.1032     |            |       |  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 207.687 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.691 hours/ns, 4.815 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    | 206.69     | 206.69     | 206.69     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15308    | 0.15308    | 0.15308    |   0.0 |  0.07
Output  | 0.00017728 | 0.00017728 | 0.00017728 |   0.0 |  0.00
Modify  | 0.74271    | 0.74271    | 0.74271    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  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 209.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.245 hours/ns, 4.769 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    | 208.67     | 208.67     | 208.67     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15504    | 0.15504    | 0.15504    |   0.0 |  0.07
Output  | 0.00017796 | 0.00017796 | 0.00017796 |   0.0 |  0.00
Modify  | 0.75361    | 0.75361    | 0.75361    |   0.0 |  0.36
Other   |            | 0.1027     |            |       |  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 210.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.549 hours/ns, 4.744 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    | 209.75     | 209.75     | 209.75     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15617    | 0.15617    | 0.15617    |   0.0 |  0.07
Output  | 0.00017713 | 0.00017713 | 0.00017713 |   0.0 |  0.00
Modify  | 0.7618     | 0.7618     | 0.7618     |   0.0 |  0.36
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:      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 206.989 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.497 hours/ns, 4.831 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    | 205.99     | 205.99     | 205.99     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15409    | 0.15409    | 0.15409    |   0.0 |  0.07
Output  | 0.00022475 | 0.00022475 | 0.00022475 |   0.0 |  0.00
Modify  | 0.74532    | 0.74532    | 0.74532    |   0.0 |  0.36
Other   |            | 0.1028     |            |       |  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 212.802 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.112 hours/ns, 4.699 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.76     | 211.76     | 211.76     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15791    | 0.15791    | 0.15791    |   0.0 |  0.07
Output  | 0.00017655 | 0.00017655 | 0.00017655 |   0.0 |  0.00
Modify  | 0.77705    | 0.77705    | 0.77705    |   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:      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 209.271 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.131 hours/ns, 4.778 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    | 208.26     | 208.26     | 208.26     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.156      | 0.156      | 0.156      |   0.0 |  0.07
Output  | 0.00059687 | 0.00059687 | 0.00059687 |   0.0 |  0.00
Modify  | 0.75216    | 0.75216    | 0.75216    |   0.0 |  0.36
Other   |            | 0.1031     |            |       |  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.119 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.144 hours/ns, 4.948 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.15     | 201.15     | 201.15     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15125    | 0.15125    | 0.15125    |   0.0 |  0.07
Output  | 0.00017779 | 0.00017779 | 0.00017779 |   0.0 |  0.00
Modify  | 0.71727    | 0.71727    | 0.71727    |   0.0 |  0.35
Other   |            | 0.1004     |            |       |  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 211.649 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.408 ns/day, 58.791 hours/ns, 4.725 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.62     | 210.62     | 210.62     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15663    | 0.15663    | 0.15663    |   0.0 |  0.07
Output  | 0.0001795  | 0.0001795  | 0.0001795  |   0.0 |  0.00
Modify  | 0.76524    | 0.76524    | 0.76524    |   0.0 |  0.36
Other   |            | 0.1036     |            |       |  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 206.707 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.419 hours/ns, 4.838 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    | 205.71     | 205.71     | 205.71     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1541     | 0.1541     | 0.1541     |   0.0 |  0.07
Output  | 0.00018116 | 0.00018116 | 0.00018116 |   0.0 |  0.00
Modify  | 0.74229    | 0.74229    | 0.74229    |   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:      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 205.559 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.100 hours/ns, 4.865 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.56     | 204.56     | 204.56     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15304    | 0.15304    | 0.15304    |   0.0 |  0.07
Output  | 0.00018094 | 0.00018094 | 0.00018094 |   0.0 |  0.00
Modify  | 0.74014    | 0.74014    | 0.74014    |   0.0 |  0.36
Other   |            | 0.103      |            |       |  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 207.964 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.768 hours/ns, 4.809 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    | 206.95     | 206.95     | 206.95     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15495    | 0.15495    | 0.15495    |   0.0 |  0.07
Output  | 0.00025031 | 0.00025031 | 0.00025031 |   0.0 |  0.00
Modify  | 0.75694    | 0.75694    | 0.75694    |   0.0 |  0.36
Other   |            | 0.1032     |            |       |  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 209.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.100 hours/ns, 4.781 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    | 208.14     | 208.14     | 208.14     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15457    | 0.15457    | 0.15457    |   0.0 |  0.07
Output  | 0.00017907 | 0.00017907 | 0.00017907 |   0.0 |  0.00
Modify  | 0.75756    | 0.75756    | 0.75756    |   0.0 |  0.36
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:      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 204.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.674 hours/ns, 4.901 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    | 203.04     | 203.04     | 203.04     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1536     | 0.1536     | 0.1536     |   0.0 |  0.08
Output  | 0.00017908 | 0.00017908 | 0.00017908 |   0.0 |  0.00
Modify  | 0.73212    | 0.73212    | 0.73212    |   0.0 |  0.36
Other   |            | 0.1027     |            |       |  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 207.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.698 hours/ns, 4.814 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    | 206.7      | 206.7      | 206.7      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15552    | 0.15552    | 0.15552    |   0.0 |  0.07
Output  | 0.0001793  | 0.0001793  | 0.0001793  |   0.0 |  0.00
Modify  | 0.75392    | 0.75392    | 0.75392    |   0.0 |  0.36
Other   |            | 0.1033     |            |       |  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 207.979 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.772 hours/ns, 4.808 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    | 206.97     | 206.97     | 206.97     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1548     | 0.1548     | 0.1548     |   0.0 |  0.07
Output  | 0.00025169 | 0.00025169 | 0.00025169 |   0.0 |  0.00
Modify  | 0.75386    | 0.75386    | 0.75386    |   0.0 |  0.36
Other   |            | 0.1041     |            |       |  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 206.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.324 hours/ns, 4.846 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    | 205.37     | 205.37     | 205.37     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15354    | 0.15354    | 0.15354    |   0.0 |  0.07
Output  | 0.00022878 | 0.00022878 | 0.00022878 |   0.0 |  0.00
Modify  | 0.7401     | 0.7401     | 0.7401     |   0.0 |  0.36
Other   |            | 0.1025     |            |       |  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 210.216 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.393 hours/ns, 4.757 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    | 209.2      | 209.2      | 209.2      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15598    | 0.15598    | 0.15598    |   0.0 |  0.07
Output  | 0.00017993 | 0.00017993 | 0.00017993 |   0.0 |  0.00
Modify  | 0.75663    | 0.75663    | 0.75663    |   0.0 |  0.36
Other   |            | 0.1019     |            |       |  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.383 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.329 hours/ns, 4.845 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    | 205.39     | 205.39     | 205.39     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15246    | 0.15246    | 0.15246    |   0.0 |  0.07
Output  | 0.00017896 | 0.00017896 | 0.00017896 |   0.0 |  0.00
Modify  | 0.73763    | 0.73763    | 0.73763    |   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:      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 203.21 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.447 hours/ns, 4.921 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    | 202.23     | 202.23     | 202.23     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15084    | 0.15084    | 0.15084    |   0.0 |  0.07
Output  | 0.00028598 | 0.00028598 | 0.00028598 |   0.0 |  0.00
Modify  | 0.72641    | 0.72641    | 0.72641    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  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 205.194 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.998 hours/ns, 4.873 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    | 204.21     | 204.21     | 204.21     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15149    | 0.15149    | 0.15149    |   0.0 |  0.07
Output  | 0.00019268 | 0.00019268 | 0.00019268 |   0.0 |  0.00
Modify  | 0.72941    | 0.72941    | 0.72941    |   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:      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 203.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.650 hours/ns, 4.903 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.95     | 202.95     | 202.95     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15119    | 0.15119    | 0.15119    |   0.0 |  0.07
Output  | 0.00017983 | 0.00017983 | 0.00017983 |   0.0 |  0.00
Modify  | 0.73416    | 0.73416    | 0.73416    |   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:      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 201.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.110 hours/ns, 4.951 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.02     | 201.02     | 201.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15008    | 0.15008    | 0.15008    |   0.0 |  0.07
Output  | 0.00018354 | 0.00018354 | 0.00018354 |   0.0 |  0.00
Modify  | 0.72056    | 0.72056    | 0.72056    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  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 209.325 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.146 hours/ns, 4.777 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    | 208.31     | 208.31     | 208.31     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15456    | 0.15456    | 0.15456    |   0.0 |  0.07
Output  | 0.00018416 | 0.00018416 | 0.00018416 |   0.0 |  0.00
Modify  | 0.75567    | 0.75567    | 0.75567    |   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:      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 205.543 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.095 hours/ns, 4.865 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.54     | 204.54     | 204.54     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15279    | 0.15279    | 0.15279    |   0.0 |  0.07
Output  | 0.00025713 | 0.00025713 | 0.00025713 |   0.0 |  0.00
Modify  | 0.74242    | 0.74242    | 0.74242    |   0.0 |  0.36
Other   |            | 0.1025     |            |       |  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 207.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.546 hours/ns, 4.827 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    | 206.17     | 206.17     | 206.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15444    | 0.15444    | 0.15444    |   0.0 |  0.07
Output  | 0.00023684 | 0.00023684 | 0.00023684 |   0.0 |  0.00
Modify  | 0.7424     | 0.7424     | 0.7424     |   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:      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 211.118 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.644 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.09     | 210.09     | 210.09     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15731    | 0.15731    | 0.15731    |   0.0 |  0.07
Output  | 0.00018257 | 0.00018257 | 0.00018257 |   0.0 |  0.00
Modify  | 0.76725    | 0.76725    | 0.76725    |   0.0 |  0.36
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.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 210.185 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.385 hours/ns, 4.758 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    | 209.17     | 209.17     | 209.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15405    | 0.15405    | 0.15405    |   0.0 |  0.07
Output  | 0.00017881 | 0.00017881 | 0.00017881 |   0.0 |  0.00
Modify  | 0.75518    | 0.75518    | 0.75518    |   0.0 |  0.36
Other   |            | 0.1025     |            |       |  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 201.489 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.969 hours/ns, 4.963 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.52     | 200.52     | 200.52     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14708    | 0.14708    | 0.14708    |   0.0 |  0.07
Output  | 0.00018084 | 0.00018084 | 0.00018084 |   0.0 |  0.00
Modify  | 0.71673    | 0.71673    | 0.71673    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  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 206.856 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.460 hours/ns, 4.834 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    | 205.86     | 205.86     | 205.86     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15107    | 0.15107    | 0.15107    |   0.0 |  0.07
Output  | 0.00023325 | 0.00023325 | 0.00023325 |   0.0 |  0.00
Modify  | 0.74619    | 0.74619    | 0.74619    |   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:      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 205.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.218 hours/ns, 4.855 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.98     | 204.98     | 204.98     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15336    | 0.15336    | 0.15336    |   0.0 |  0.07
Output  | 0.00022223 | 0.00022223 | 0.00022223 |   0.0 |  0.00
Modify  | 0.74344    | 0.74344    | 0.74344    |   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:      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 209.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.077 hours/ns, 4.783 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    | 208.06     | 208.06     | 208.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15359    | 0.15359    | 0.15359    |   0.0 |  0.07
Output  | 0.00022796 | 0.00022796 | 0.00022796 |   0.0 |  0.00
Modify  | 0.75768    | 0.75768    | 0.75768    |   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:      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 207.807 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.724 hours/ns, 4.812 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    | 206.81     | 206.81     | 206.81     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15205    | 0.15205    | 0.15205    |   0.0 |  0.07
Output  | 0.0011763  | 0.0011763  | 0.0011763  |   0.0 |  0.00
Modify  | 0.73927    | 0.73927    | 0.73927    |   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.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 209.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.132 hours/ns, 4.778 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    | 208.26     | 208.26     | 208.26     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15435    | 0.15435    | 0.15435    |   0.0 |  0.07
Output  | 0.0002245  | 0.0002245  | 0.0002245  |   0.0 |  0.00
Modify  | 0.75263    | 0.75263    | 0.75263    |   0.0 |  0.36
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:      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 205.846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.179 hours/ns, 4.858 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    | 204.86     | 204.86     | 204.86     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15094    | 0.15094    | 0.15094    |   0.0 |  0.07
Output  | 0.00022984 | 0.00022984 | 0.00022984 |   0.0 |  0.00
Modify  | 0.73252    | 0.73252    | 0.73252    |   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:      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 206.926 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.480 hours/ns, 4.833 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    | 205.93     | 205.93     | 205.93     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15298    | 0.15298    | 0.15298    |   0.0 |  0.07
Output  | 0.00018081 | 0.00018081 | 0.00018081 |   0.0 |  0.00
Modify  | 0.74371    | 0.74371    | 0.74371    |   0.0 |  0.36
Other   |            | 0.1023     |            |       |  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 201.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.890 hours/ns, 4.970 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.24     | 200.24     | 200.24     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14953    | 0.14953    | 0.14953    |   0.0 |  0.07
Output  | 0.00017916 | 0.00017916 | 0.00017916 |   0.0 |  0.00
Modify  | 0.71471    | 0.71471    | 0.71471    |   0.0 |  0.36
Other   |            | 0.1        |            |       |  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 205.611 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.114 hours/ns, 4.864 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    | 204.62     | 204.62     | 204.62     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15119    | 0.15119    | 0.15119    |   0.0 |  0.07
Output  | 0.00028259 | 0.00028259 | 0.00028259 |   0.0 |  0.00
Modify  | 0.73908    | 0.73908    | 0.73908    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  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 211.261 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.684 hours/ns, 4.733 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.24     | 210.24     | 210.24     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15465    | 0.15465    | 0.15465    |   0.0 |  0.07
Output  | 0.00022076 | 0.00022076 | 0.00022076 |   0.0 |  0.00
Modify  | 0.75823    | 0.75823    | 0.75823    |   0.0 |  0.36
Other   |            | 0.1032     |            |       |  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 206.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.280 hours/ns, 4.849 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    | 205.21     | 205.21     | 205.21     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15299    | 0.15299    | 0.15299    |   0.0 |  0.07
Output  | 0.00017456 | 0.00017456 | 0.00017456 |   0.0 |  0.00
Modify  | 0.73904    | 0.73904    | 0.73904    |   0.0 |  0.36
Other   |            | 0.1026     |            |       |  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.473 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.414 ns/day, 57.909 hours/ns, 4.797 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.46     | 207.46     | 207.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15474    | 0.15474    | 0.15474    |   0.0 |  0.07
Output  | 0.0002221  | 0.0002221  | 0.0002221  |   0.0 |  0.00
Modify  | 0.75409    | 0.75409    | 0.75409    |   0.0 |  0.36
Other   |            | 0.1026     |            |       |  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 207.085 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.524 hours/ns, 4.829 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    | 206.09     | 206.09     | 206.09     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15331    | 0.15331    | 0.15331    |   0.0 |  0.07
Output  | 0.00018134 | 0.00018134 | 0.00018134 |   0.0 |  0.00
Modify  | 0.74436    | 0.74436    | 0.74436    |   0.0 |  0.36
Other   |            | 0.1019     |            |       |  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 202.228 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.174 hours/ns, 4.945 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.26     | 201.26     | 201.26     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14995    | 0.14995    | 0.14995    |   0.0 |  0.07
Output  | 0.00017615 | 0.00017615 | 0.00017615 |   0.0 |  0.00
Modify  | 0.71816    | 0.71816    | 0.71816    |   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:      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 203.252 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.459 hours/ns, 4.920 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    | 202.27     | 202.27     | 202.27     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14944    | 0.14944    | 0.14944    |   0.0 |  0.07
Output  | 0.00028441 | 0.00028441 | 0.00028441 |   0.0 |  0.00
Modify  | 0.72882    | 0.72882    | 0.72882    |   0.0 |  0.36
Other   |            | 0.1018     |            |       |  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 198.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.251 hours/ns, 5.028 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    | 197.96     | 197.96     | 197.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14663    | 0.14663    | 0.14663    |   0.0 |  0.07
Output  | 0.00023431 | 0.00023431 | 0.00023431 |   0.0 |  0.00
Modify  | 0.70186    | 0.70186    | 0.70186    |   0.0 |  0.35
Other   |            | 0.09994    |            |       |  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 203.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.530 hours/ns, 4.914 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    | 202.53     | 202.53     | 202.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15054    | 0.15054    | 0.15054    |   0.0 |  0.07
Output  | 0.00027464 | 0.00027464 | 0.00027464 |   0.0 |  0.00
Modify  | 0.72617    | 0.72617    | 0.72617    |   0.0 |  0.36
Other   |            | 0.1013     |            |       |  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 205.054 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.959 hours/ns, 4.877 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    | 204.06     | 204.06     | 204.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15185    | 0.15185    | 0.15185    |   0.0 |  0.07
Output  | 0.00022244 | 0.00022244 | 0.00022244 |   0.0 |  0.00
Modify  | 0.73806    | 0.73806    | 0.73806    |   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:      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 204.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.774 hours/ns, 4.893 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    | 203.4      | 203.4      | 203.4      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15073    | 0.15073    | 0.15073    |   0.0 |  0.07
Output  | 0.00017234 | 0.00017234 | 0.00017234 |   0.0 |  0.00
Modify  | 0.73477    | 0.73477    | 0.73477    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  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 206.868 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.463 hours/ns, 4.834 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    | 205.86     | 205.86     | 205.86     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15288    | 0.15288    | 0.15288    |   0.0 |  0.07
Output  | 0.00021845 | 0.00021845 | 0.00021845 |   0.0 |  0.00
Modify  | 0.75022    | 0.75022    | 0.75022    |   0.0 |  0.36
Other   |            | 0.103      |            |       |  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 203.478 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.522 hours/ns, 4.915 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    | 202.49     | 202.49     | 202.49     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15089    | 0.15089    | 0.15089    |   0.0 |  0.07
Output  | 0.00017704 | 0.00017704 | 0.00017704 |   0.0 |  0.00
Modify  | 0.73371    | 0.73371    | 0.73371    |   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:      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 200.412 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.670 hours/ns, 4.990 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    | 199.45     | 199.45     | 199.45     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14752    | 0.14752    | 0.14752    |   0.0 |  0.07
Output  | 0.00018125 | 0.00018125 | 0.00018125 |   0.0 |  0.00
Modify  | 0.71224    | 0.71224    | 0.71224    |   0.0 |  0.36
Other   |            | 0.1003     |            |       |  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 205.37 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.047 hours/ns, 4.869 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    | 204.38     | 204.38     | 204.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15054    | 0.15054    | 0.15054    |   0.0 |  0.07
Output  | 0.00028986 | 0.00028986 | 0.00028986 |   0.0 |  0.00
Modify  | 0.73514    | 0.73514    | 0.73514    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  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 203.394 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.498 hours/ns, 4.917 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    | 202.42     | 202.42     | 202.42     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15158    | 0.15158    | 0.15158    |   0.0 |  0.07
Output  | 0.00018089 | 0.00018089 | 0.00018089 |   0.0 |  0.00
Modify  | 0.72455    | 0.72455    | 0.72455    |   0.0 |  0.36
Other   |            | 0.1018     |            |       |  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 201.573 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.993 hours/ns, 4.961 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    | 200.6      | 200.6      | 200.6      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14908    | 0.14908    | 0.14908    |   0.0 |  0.07
Output  | 0.00017676 | 0.00017676 | 0.00017676 |   0.0 |  0.00
Modify  | 0.71938    | 0.71938    | 0.71938    |   0.0 |  0.36
Other   |            | 0.1013     |            |       |  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 201.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.957 hours/ns, 4.964 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.47     | 200.47     | 200.47     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14917    | 0.14917    | 0.14917    |   0.0 |  0.07
Output  | 0.00018087 | 0.00018087 | 0.00018087 |   0.0 |  0.00
Modify  | 0.72099    | 0.72099    | 0.72099    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  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 197.696 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.915 hours/ns, 5.058 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    | 196.75     | 196.75     | 196.75     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14721    | 0.14721    | 0.14721    |   0.0 |  0.07
Output  | 0.0001752  | 0.0001752  | 0.0001752  |   0.0 |  0.00
Modify  | 0.70146    | 0.70146    | 0.70146    |   0.0 |  0.35
Other   |            | 0.1002     |            |       |  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 202.218 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.172 hours/ns, 4.945 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.25     | 201.25     | 201.25     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14948    | 0.14948    | 0.14948    |   0.0 |  0.07
Output  | 0.00025568 | 0.00025568 | 0.00025568 |   0.0 |  0.00
Modify  | 0.71943    | 0.71943    | 0.71943    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  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 199.624 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.451 hours/ns, 5.009 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    | 198.67     | 198.67     | 198.67     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14837    | 0.14837    | 0.14837    |   0.0 |  0.07
Output  | 0.00022031 | 0.00022031 | 0.00022031 |   0.0 |  0.00
Modify  | 0.70316    | 0.70316    | 0.70316    |   0.0 |  0.35
Other   |            | 0.1004     |            |       |  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 201.866 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.074 hours/ns, 4.954 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.89     | 200.89     | 200.89     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14867    | 0.14867    | 0.14867    |   0.0 |  0.07
Output  | 0.00051843 | 0.00051843 | 0.00051843 |   0.0 |  0.00
Modify  | 0.72249    | 0.72249    | 0.72249    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  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 203.069 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.408 hours/ns, 4.924 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    | 202.09     | 202.09     | 202.09     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15078    | 0.15078    | 0.15078    |   0.0 |  0.07
Output  | 0.00022513 | 0.00022513 | 0.00022513 |   0.0 |  0.00
Modify  | 0.72667    | 0.72667    | 0.72667    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  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 205.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.161 hours/ns, 4.860 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    | 204.79     | 204.79     | 204.79     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15158    | 0.15158    | 0.15158    |   0.0 |  0.07
Output  | 0.00022453 | 0.00022453 | 0.00022453 |   0.0 |  0.00
Modify  | 0.73985    | 0.73985    | 0.73985    |   0.0 |  0.36
Other   |            | 0.1016     |            |       |  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 206.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.416 hours/ns, 4.838 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    | 205.69     | 205.69     | 205.69     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15343    | 0.15343    | 0.15343    |   0.0 |  0.07
Output  | 0.0002382  | 0.0002382  | 0.0002382  |   0.0 |  0.00
Modify  | 0.74922    | 0.74922    | 0.74922    |   0.0 |  0.36
Other   |            | 0.1035     |            |       |  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 202.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.170 hours/ns, 4.945 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.23     | 201.23     | 201.23     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15103    | 0.15103    | 0.15103    |   0.0 |  0.07
Output  | 0.00023124 | 0.00023124 | 0.00023124 |   0.0 |  0.00
Modify  | 0.72418    | 0.72418    | 0.72418    |   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:      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 205.651 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.125 hours/ns, 4.863 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    | 204.66     | 204.66     | 204.66     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15177    | 0.15177    | 0.15177    |   0.0 |  0.07
Output  | 0.00017985 | 0.00017985 | 0.00017985 |   0.0 |  0.00
Modify  | 0.73967    | 0.73967    | 0.73967    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  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 206.016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.227 hours/ns, 4.854 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    | 205.02     | 205.02     | 205.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15114    | 0.15114    | 0.15114    |   0.0 |  0.07
Output  | 0.00024947 | 0.00024947 | 0.00024947 |   0.0 |  0.00
Modify  | 0.74147    | 0.74147    | 0.74147    |   0.0 |  0.36
Other   |            | 0.1031     |            |       |  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 203.612 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.559 hours/ns, 4.911 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    | 202.63     | 202.63     | 202.63     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15       | 0.15       | 0.15       |   0.0 |  0.07
Output  | 0.00028074 | 0.00028074 | 0.00028074 |   0.0 |  0.00
Modify  | 0.72726    | 0.72726    | 0.72726    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  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 203.71 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.586 hours/ns, 4.909 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    | 202.73     | 202.73     | 202.73     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1503     | 0.1503     | 0.1503     |   0.0 |  0.07
Output  | 0.00017657 | 0.00017657 | 0.00017657 |   0.0 |  0.00
Modify  | 0.7255     | 0.7255     | 0.7255     |   0.0 |  0.36
Other   |            | 0.1018     |            |       |  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 203.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.634 hours/ns, 4.905 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    | 202.9      | 202.9      | 202.9      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15069    | 0.15069    | 0.15069    |   0.0 |  0.07
Output  | 0.00031291 | 0.00031291 | 0.00031291 |   0.0 |  0.00
Modify  | 0.73172    | 0.73172    | 0.73172    |   0.0 |  0.36
Other   |            | 0.1018     |            |       |  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 209.642 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.234 hours/ns, 4.770 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    | 208.62     | 208.62     | 208.62     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15448    | 0.15448    | 0.15448    |   0.0 |  0.07
Output  | 0.00017684 | 0.00017684 | 0.00017684 |   0.0 |  0.00
Modify  | 0.76391    | 0.76391    | 0.76391    |   0.0 |  0.36
Other   |            | 0.1037     |            |       |  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 205.722 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.145 hours/ns, 4.861 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    | 204.73     | 204.73     | 204.73     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15482    | 0.15482    | 0.15482    |   0.0 |  0.08
Output  | 0.00017905 | 0.00017905 | 0.00017905 |   0.0 |  0.00
Modify  | 0.73761    | 0.73761    | 0.73761    |   0.0 |  0.36
Other   |            | 0.1028     |            |       |  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 206.791 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.442 hours/ns, 4.836 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    | 205.79     | 205.79     | 205.79     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15361    | 0.15361    | 0.15361    |   0.0 |  0.07
Output  | 0.00018264 | 0.00018264 | 0.00018264 |   0.0 |  0.00
Modify  | 0.74706    | 0.74706    | 0.74706    |   0.0 |  0.36
Other   |            | 0.1027     |            |       |  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 204.583 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.829 hours/ns, 4.888 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.59     | 203.59     | 203.59     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15151    | 0.15151    | 0.15151    |   0.0 |  0.07
Output  | 0.00017792 | 0.00017792 | 0.00017792 |   0.0 |  0.00
Modify  | 0.7352     | 0.7352     | 0.7352     |   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.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 202.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.212 hours/ns, 4.942 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.39     | 201.39     | 201.39     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14953    | 0.14953    | 0.14953    |   0.0 |  0.07
Output  | 0.00017542 | 0.00017542 | 0.00017542 |   0.0 |  0.00
Modify  | 0.72248    | 0.72248    | 0.72248    |   0.0 |  0.36
Other   |            | 0.1013     |            |       |  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 209.355 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.154 hours/ns, 4.777 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    | 208.34     | 208.34     | 208.34     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15513    | 0.15513    | 0.15513    |   0.0 |  0.07
Output  | 0.00022728 | 0.00022728 | 0.00022728 |   0.0 |  0.00
Modify  | 0.75409    | 0.75409    | 0.75409    |   0.0 |  0.36
Other   |            | 0.1032     |            |       |  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 205.397 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.055 hours/ns, 4.869 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    | 204.41     | 204.41     | 204.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15162    | 0.15162    | 0.15162    |   0.0 |  0.07
Output  | 0.00025892 | 0.00025892 | 0.00025892 |   0.0 |  0.00
Modify  | 0.73243    | 0.73243    | 0.73243    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  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 204.412 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.781 hours/ns, 4.892 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    | 203.42     | 203.42     | 203.42     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15174    | 0.15174    | 0.15174    |   0.0 |  0.07
Output  | 0.00031328 | 0.00031328 | 0.00031328 |   0.0 |  0.00
Modify  | 0.73359    | 0.73359    | 0.73359    |   0.0 |  0.36
Other   |            | 0.1025     |            |       |  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 206.164 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.268 hours/ns, 4.851 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    | 205.17     | 205.17     | 205.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15295    | 0.15295    | 0.15295    |   0.0 |  0.07
Output  | 0.00018054 | 0.00018054 | 0.00018054 |   0.0 |  0.00
Modify  | 0.73749    | 0.73749    | 0.73749    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  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 197.801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.945 hours/ns, 5.056 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    | 196.86     | 196.86     | 196.86     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14649    | 0.14649    | 0.14649    |   0.0 |  0.07
Output  | 0.00018181 | 0.00018181 | 0.00018181 |   0.0 |  0.00
Modify  | 0.69699    | 0.69699    | 0.69699    |   0.0 |  0.35
Other   |            | 0.09976    |            |       |  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 204.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.836 hours/ns, 4.887 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    | 203.62     | 203.62     | 203.62     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15078    | 0.15078    | 0.15078    |   0.0 |  0.07
Output  | 0.00022466 | 0.00022466 | 0.00022466 |   0.0 |  0.00
Modify  | 0.73331    | 0.73331    | 0.73331    |   0.0 |  0.36
Other   |            | 0.1023     |            |       |  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 206.411 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.336 hours/ns, 4.845 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    | 205.41     | 205.41     | 205.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15318    | 0.15318    | 0.15318    |   0.0 |  0.07
Output  | 0.00017965 | 0.00017965 | 0.00017965 |   0.0 |  0.00
Modify  | 0.7437     | 0.7437     | 0.7437     |   0.0 |  0.36
Other   |            | 0.1027     |            |       |  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