# 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_JeongLee_2020_PdC__MO_068985622065_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_068985622065_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.52829   -630.52829 
Loop time of 181.494 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.476 ns/day, 50.415 hours/ns, 5.510 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    | 180.6      | 180.6      | 180.6      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13964    | 0.13964    | 0.13964    |   0.0 |  0.08
Output  | 0.0002226  | 0.0002226  | 0.0002226  |   0.0 |  0.00
Modify  | 0.65147    | 0.65147    | 0.65147    |   0.0 |  0.36
Other   |            | 0.09854    |            |       |  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.52829   -630.52829 
    2000   -15361.482   -15361.482   -15501.463   -15501.463    270.80155    270.80155    59455.883    59455.883     1331.002     1331.002 
Loop time of 190.047 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.791 hours/ns, 5.262 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 189.17     | 189.17     | 189.17     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14061    | 0.14061    | 0.14061    |   0.0 |  0.07
Output  | 0.00021579 | 0.00021579 | 0.00021579 |   0.0 |  0.00
Modify  | 0.64107    | 0.64107    | 0.64107    |   0.0 |  0.34
Other   |            | 0.09781    |            |       |  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.002     1331.002 
    3000   -15365.649   -15365.649   -15503.333   -15503.333    266.35891    266.35891     59551.88     59551.88   -1897.5306   -1897.5306 
Loop time of 201.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.944 hours/ns, 4.965 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.45     | 200.45     | 200.45     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14839    | 0.14839    | 0.14839    |   0.0 |  0.07
Output  | 0.00026331 | 0.00026331 | 0.00026331 |   0.0 |  0.00
Modify  | 0.69824    | 0.69824    | 0.69824    |   0.0 |  0.35
Other   |            | 0.1006     |            |       |  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.5306   -1897.5306 
    4000   -15357.776   -15357.776   -15503.221   -15503.221    281.37341    281.37341    59529.217    59529.217   -916.95634   -916.95634 
Loop time of 224.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.462 hours/ns, 4.447 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.78     | 223.78     | 223.78     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16461    | 0.16461    | 0.16461    |   0.0 |  0.07
Output  | 0.00021589 | 0.00021589 | 0.00021589 |   0.0 |  0.00
Modify  | 0.81417    | 0.81417    | 0.81417    |   0.0 |  0.36
Other   |            | 0.1068     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.95634   -916.95634 
    5000   -15364.683   -15364.683   -15508.087   -15508.087    277.42616    277.42616    59445.262    59445.262    1031.7004    1031.7004 
Loop time of 225.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.525 hours/ns, 4.443 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.01     | 224.01     | 224.01     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16486    | 0.16486    | 0.16486    |   0.0 |  0.07
Output  | 0.00018259 | 0.00018259 | 0.00018259 |   0.0 |  0.00
Modify  | 0.8123     | 0.8123     | 0.8123     |   0.0 |  0.36
Other   |            | 0.1061     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.730879912572, Press = -979.114899372801
next a
jump SELF top
variable a loop 2000
run 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.7004    1031.7004 
    6000    -15360.94    -15360.94   -15502.954   -15502.954    274.73738    274.73738    59480.341    59480.341    518.01457    518.01457 
Loop time of 225.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.576 hours/ns, 4.439 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.16     | 224.16     | 224.16     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16582    | 0.16582    | 0.16582    |   0.0 |  0.07
Output  | 0.00024135 | 0.00024135 | 0.00024135 |   0.0 |  0.00
Modify  | 0.83659    | 0.83659    | 0.83659    |   0.0 |  0.37
Other   |            | 0.1072     |            |       |  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.121543532281, Press = -3.02376382913592
next a
jump SELF top
variable a loop 2000
run 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.01457    518.01457 
    7000   -15362.909   -15362.909   -15502.534   -15502.534    270.11489    270.11489     59468.89     59468.89    914.25486    914.25486 
Loop time of 192.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.373 hours/ns, 5.204 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.23     | 191.23     | 191.23     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14448    | 0.14448    | 0.14448    |   0.0 |  0.08
Output  | 0.00018529 | 0.00018529 | 0.00018529 |   0.0 |  0.00
Modify  | 0.66874    | 0.66874    | 0.66874    |   0.0 |  0.35
Other   |            | 0.09543    |            |       |  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.904852397684, Press = -14.2649032078068
next a
jump SELF top
variable a loop 2000
run 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.25486    914.25486 
    8000   -15367.213   -15367.213   -15505.773   -15505.773    268.05403    268.05403    59475.984    59475.984    227.46221    227.46221 
Loop time of 201.952 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.098 hours/ns, 4.952 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.98     | 200.98     | 200.98     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15087    | 0.15087    | 0.15087    |   0.0 |  0.07
Output  | 0.00022674 | 0.00022674 | 0.00022674 |   0.0 |  0.00
Modify  | 0.72224    | 0.72224    | 0.72224    |   0.0 |  0.36
Other   |            | 0.09908    |            |       |  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.142676119582, Press = -15.9254009966469
next a
jump SELF top
variable a loop 2000
run 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.05403    268.05403    59475.984    59475.984    227.46221    227.46221 
    9000   -15360.098   -15360.098   -15501.293   -15501.293    273.15148    273.15148    59524.679    59524.679    -686.4654    -686.4654 
Loop time of 192.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.378 hours/ns, 5.204 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    | 191.25     | 191.25     | 191.25     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14478    | 0.14478    | 0.14478    |   0.0 |  0.08
Output  | 0.00022709 | 0.00022709 | 0.00022709 |   0.0 |  0.00
Modify  | 0.67304    | 0.67304    | 0.67304    |   0.0 |  0.35
Other   |            | 0.09702    |            |       |  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.839564602791, Press = -12.9231692979599
next a
jump SELF top
variable a loop 2000
run 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.4654    -686.4654 
   10000   -15362.534   -15362.534   -15504.009   -15504.009    273.69288    273.69288    59476.619    59476.619    590.29903    590.29903 
Loop time of 191.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.295 hours/ns, 5.212 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.95     | 190.95     | 190.95     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14549    | 0.14549    | 0.14549    |   0.0 |  0.08
Output  | 0.00018176 | 0.00018176 | 0.00018176 |   0.0 |  0.00
Modify  | 0.6705     | 0.6705     | 0.6705     |   0.0 |  0.35
Other   |            | 0.09439    |            |       |  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.357656193616, Press = -9.61099887266395
next a
jump SELF top
variable a loop 2000
run 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.69288    273.69288    59476.619    59476.619    590.29903    590.29903 
   11000   -15358.117   -15358.117   -15502.265   -15502.265    278.86436    278.86436    59538.166    59538.166   -1173.9804   -1173.9804 
Loop time of 191.795 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.450 ns/day, 53.276 hours/ns, 5.214 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.89     | 190.89     | 190.89     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1457     | 0.1457     | 0.1457     |   0.0 |  0.08
Output  | 0.00018059 | 0.00018059 | 0.00018059 |   0.0 |  0.00
Modify  | 0.66953    | 0.66953    | 0.66953    |   0.0 |  0.35
Other   |            | 0.09375    |            |       |  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.390448528881, Press = 1.01235123333317
next a
jump SELF top
variable a loop 2000
run 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.9804   -1173.9804 
   12000   -15363.052   -15363.052   -15504.779   -15504.779    274.17962    274.17962    59501.218    59501.218   -343.98628   -343.98628 
Loop time of 191.723 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.256 hours/ns, 5.216 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.81     | 190.81     | 190.81     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14611    | 0.14611    | 0.14611    |   0.0 |  0.08
Output  | 0.00018088 | 0.00018088 | 0.00018088 |   0.0 |  0.00
Modify  | 0.66854    | 0.66854    | 0.66854    |   0.0 |  0.35
Other   |            | 0.0947     |            |       |  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.268924603226, Press = -9.11836353063179
next a
jump SELF top
variable a loop 2000
run 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.17962    274.17962    59501.218    59501.218   -343.98628   -343.98628 
   13000    -15362.61    -15362.61   -15502.453   -15502.453     270.5365     270.5365    59477.439    59477.439    645.10682    645.10682 
Loop time of 197.056 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.738 hours/ns, 5.075 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.11     | 196.11     | 196.11     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14826    | 0.14826    | 0.14826    |   0.0 |  0.08
Output  | 0.00018243 | 0.00018243 | 0.00018243 |   0.0 |  0.00
Modify  | 0.69951    | 0.69951    | 0.69951    |   0.0 |  0.35
Other   |            | 0.09759    |            |       |  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.259636234804, Press = -0.553488519332231
next a
jump SELF top
variable a loop 2000
run 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.5365     270.5365    59477.439    59477.439    645.10682    645.10682 
   14000   -15355.873   -15355.873   -15499.251   -15499.251    277.37321    277.37321    59529.657    59529.657   -554.80869   -554.80869 
Loop time of 201.241 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.900 hours/ns, 4.969 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.27     | 200.27     | 200.27     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15281    | 0.15281    | 0.15281    |   0.0 |  0.08
Output  | 0.00017849 | 0.00017849 | 0.00017849 |   0.0 |  0.00
Modify  | 0.72085    | 0.72085    | 0.72085    |   0.0 |  0.36
Other   |            | 0.09729    |            |       |  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.239817598505, Press = -4.36917815968568
next a
jump SELF top
variable a loop 2000
run 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.873   -15355.873   -15499.251   -15499.251    277.37321    277.37321    59529.657    59529.657   -554.80869   -554.80869 
   15000   -15364.026   -15364.026    -15504.16    -15504.16    271.09896    271.09896    59494.136    59494.136   -94.629081   -94.629081 
Loop time of 225.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.603 hours/ns, 4.437 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.26     | 224.26     | 224.26     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16623    | 0.16623    | 0.16623    |   0.0 |  0.07
Output  | 0.00057232 | 0.00057232 | 0.00057232 |   0.0 |  0.00
Modify  | 0.83718    | 0.83718    | 0.83718    |   0.0 |  0.37
Other   |            | 0.107      |            |       |  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.306865112773, Press = -2.18920741262269
next a
jump SELF top
variable a loop 2000
run 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.09896    271.09896    59494.136    59494.136   -94.629081   -94.629081 
   16000   -15359.574   -15359.574   -15501.015   -15501.015    273.62557    273.62557    59545.343    59545.343   -1237.4892   -1237.4892 
Loop time of 225.181 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.07     | 224.07     | 224.07     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16584    | 0.16584    | 0.16584    |   0.0 |  0.07
Output  | 0.00025305 | 0.00025305 | 0.00025305 |   0.0 |  0.00
Modify  | 0.84118    | 0.84118    | 0.84118    |   0.0 |  0.37
Other   |            | 0.1075     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.475619860738, Press = -4.38848249573903
next a
jump SELF top
variable a loop 2000
run 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.574   -15359.574   -15501.015   -15501.015    273.62557    273.62557    59545.343    59545.343   -1237.4892   -1237.4892 
   17000   -15364.168   -15364.168   -15504.621   -15504.621     271.7156     271.7156     59482.94     59482.94    242.26197    242.26197 
Loop time of 225.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.559 hours/ns, 4.440 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.1      | 224.1      | 224.1      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16611    | 0.16611    | 0.16611    |   0.0 |  0.07
Output  | 0.00017979 | 0.00017979 | 0.00017979 |   0.0 |  0.00
Modify  | 0.84033    | 0.84033    | 0.84033    |   0.0 |  0.37
Other   |            | 0.1071     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.417123734592, Press = -0.635921941645851
next a
jump SELF top
variable a loop 2000
run 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.168   -15364.168   -15504.621   -15504.621     271.7156     271.7156     59482.94     59482.94    242.26197    242.26197 
   18000   -15361.002   -15361.002    -15503.48    -15503.48    275.63446    275.63446    59531.981    59531.981   -1198.4938   -1198.4938 
Loop time of 210.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.468 hours/ns, 4.751 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.46     | 209.46     | 209.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15523    | 0.15523    | 0.15523    |   0.0 |  0.07
Output  | 0.00018092 | 0.00018092 | 0.00018092 |   0.0 |  0.00
Modify  | 0.76643    | 0.76643    | 0.76643    |   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:      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.510145470545, Press = -3.67122650412742
next a
jump SELF top
variable a loop 2000
run 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.002   -15361.002    -15503.48    -15503.48    275.63446    275.63446    59531.981    59531.981   -1198.4938   -1198.4938 
   19000   -15360.986   -15360.986   -15505.171   -15505.171    278.93571    278.93571    59440.354    59440.354    1654.9885    1654.9885 
Loop time of 199.135 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.315 hours/ns, 5.022 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.17     | 198.17     | 198.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14851    | 0.14851    | 0.14851    |   0.0 |  0.07
Output  | 0.0001834  | 0.0001834  | 0.0001834  |   0.0 |  0.00
Modify  | 0.71019    | 0.71019    | 0.71019    |   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:      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.481477482996, Press = -2.17533333470576
next a
jump SELF top
variable a loop 2000
run 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.986   -15360.986   -15505.171   -15505.171    278.93571    278.93571    59440.354    59440.354    1654.9885    1654.9885 
   20000   -15362.592   -15362.592   -15505.022   -15505.022    275.53992    275.53992    59527.224    59527.224   -1251.6837   -1251.6837 
Loop time of 192.421 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.449 ns/day, 53.450 hours/ns, 5.197 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.5      | 191.5      | 191.5      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14133    | 0.14133    | 0.14133    |   0.0 |  0.07
Output  | 0.00018121 | 0.00018121 | 0.00018121 |   0.0 |  0.00
Modify  | 0.67773    | 0.67773    | 0.67773    |   0.0 |  0.35
Other   |            | 0.1001     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.534933035837, Press = -1.23183624332061
next a
jump SELF top
variable a loop 2000
run 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.592   -15362.592   -15505.022   -15505.022    275.53992    275.53992    59527.224    59527.224   -1251.6837   -1251.6837 
   21000   -15358.891   -15358.891    -15503.59    -15503.59    279.92984    279.92984    59518.367    59518.367   -651.80324   -651.80324 
Loop time of 210.853 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.570 hours/ns, 4.743 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.83     | 209.83     | 209.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15503    | 0.15503    | 0.15503    |   0.0 |  0.07
Output  | 0.00018108 | 0.00018108 | 0.00018108 |   0.0 |  0.00
Modify  | 0.7618     | 0.7618     | 0.7618     |   0.0 |  0.36
Other   |            | 0.1043     |            |       |  0.05

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

Total # of neighbors = 312048
Ave neighs/atom = 78.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.499264076018, Press = -5.74570971199717
next a
jump SELF top
variable a loop 2000
run 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.891   -15358.891    -15503.59    -15503.59    279.92984    279.92984    59518.367    59518.367   -651.80324   -651.80324 
   22000   -15363.416   -15363.416   -15504.892   -15504.892    273.69494    273.69494     59467.91     59467.91    765.77061    765.77061 
Loop time of 226.229 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.11     | 225.11     | 225.11     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1652     | 0.1652     | 0.1652     |   0.0 |  0.07
Output  | 0.00023658 | 0.00023658 | 0.00023658 |   0.0 |  0.00
Modify  | 0.84795    | 0.84795    | 0.84795    |   0.0 |  0.37
Other   |            | 0.1091     |            |       |  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.492586326293, Press = 0.125234554726392
next a
jump SELF top
variable a loop 2000
run 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.416   -15363.416   -15504.892   -15504.892    273.69494    273.69494     59467.91     59467.91    765.77061    765.77061 
   23000   -15367.656   -15367.656   -15505.258   -15505.258    266.19931    266.19931    59484.858    59484.858    25.403908    25.403908 
Loop time of 225.126 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.02     | 224.02     | 224.02     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1646     | 0.1646     | 0.1646     |   0.0 |  0.07
Output  | 0.00018278 | 0.00018278 | 0.00018278 |   0.0 |  0.00
Modify  | 0.83274    | 0.83274    | 0.83274    |   0.0 |  0.37
Other   |            | 0.1086     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.434048184508, Press = -2.94423272942737
next a
jump SELF top
variable a loop 2000
run 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   -15367.656   -15367.656   -15505.258   -15505.258    266.19931    266.19931    59484.858    59484.858    25.403908    25.403908 
   24000   -15360.599   -15360.599   -15502.829   -15502.829    275.15453    275.15453    59477.254    59477.254    717.94437    717.94437 
Loop time of 225.389 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.608 hours/ns, 4.437 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.28     | 224.28     | 224.28     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16675    | 0.16675    | 0.16675    |   0.0 |  0.07
Output  | 0.00029836 | 0.00029836 | 0.00029836 |   0.0 |  0.00
Modify  | 0.8393     | 0.8393     | 0.8393     |   0.0 |  0.37
Other   |            | 0.1075     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.381554727904, Press = -1.94436021328287
next a
jump SELF top
variable a loop 2000
run 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.599   -15360.599   -15502.829   -15502.829    275.15453    275.15453    59477.254    59477.254    717.94437    717.94437 
   25000   -15363.878   -15363.878   -15503.905   -15503.905    270.89009    270.89009    59460.976    59460.976    1008.9034    1008.9034 
Loop time of 225.303 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.19     | 224.19     | 224.19     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16435    | 0.16435    | 0.16435    |   0.0 |  0.07
Output  | 0.00023649 | 0.00023649 | 0.00023649 |   0.0 |  0.00
Modify  | 0.83867    | 0.83867    | 0.83867    |   0.0 |  0.37
Other   |            | 0.1089     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.40658300122, Press = -1.01981646039292
next a
jump SELF top
variable a loop 2000
run 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   -15363.878   -15363.878   -15503.905   -15503.905    270.89009    270.89009    59460.976    59460.976    1008.9034    1008.9034 
   26000   -15361.329   -15361.329    -15503.48    -15503.48    275.00095    275.00095    59518.408    59518.408   -697.88806   -697.88806 
Loop time of 225.338 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.22     | 224.22     | 224.22     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16521    | 0.16521    | 0.16521    |   0.0 |  0.07
Output  | 0.00018157 | 0.00018157 | 0.00018157 |   0.0 |  0.00
Modify  | 0.84485    | 0.84485    | 0.84485    |   0.0 |  0.37
Other   |            | 0.1086     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.365887994624, Press = -1.41375988108779
next a
jump SELF top
variable a loop 2000
run 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   -15361.329   -15361.329    -15503.48    -15503.48    275.00095    275.00095    59518.408    59518.408   -697.88806   -697.88806 
   27000   -15364.334   -15364.334   -15505.123   -15505.123    272.36492    272.36492    59472.318    59472.318      605.742      605.742 
Loop time of 225.584 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.662 hours/ns, 4.433 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.47     | 224.47     | 224.47     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16451    | 0.16451    | 0.16451    |   0.0 |  0.07
Output  | 0.00022851 | 0.00022851 | 0.00022851 |   0.0 |  0.00
Modify  | 0.83587    | 0.83587    | 0.83587    |   0.0 |  0.37
Other   |            | 0.108      |            |       |  0.05

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

Total # of neighbors = 312034
Ave neighs/atom = 78.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.284229372186, Press = -2.03001225202635
next a
jump SELF top
variable a loop 2000
run 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   -15364.334   -15364.334   -15505.123   -15505.123    272.36492    272.36492    59472.318    59472.318      605.742      605.742 
   28000   -15359.971   -15359.971   -15503.013   -15503.013    276.72471    276.72471    59474.586    59474.586     843.8507     843.8507 
Loop time of 198.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.212 hours/ns, 5.031 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.81     | 197.81     | 197.81     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14693    | 0.14693    | 0.14693    |   0.0 |  0.07
Output  | 0.00017805 | 0.00017805 | 0.00017805 |   0.0 |  0.00
Modify  | 0.70564    | 0.70564    | 0.70564    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  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.253881381679, Press = -0.646116370460254
next a
jump SELF top
variable a loop 2000
run 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   -15359.971   -15359.971   -15503.013   -15503.013    276.72471    276.72471    59474.586    59474.586     843.8507     843.8507 
   29000   -15365.594   -15365.594   -15504.232   -15504.232    268.20537    268.20537    59559.173    59559.173   -2152.6074   -2152.6074 
Loop time of 197.339 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.816 hours/ns, 5.067 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.4      | 196.4      | 196.4      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14476    | 0.14476    | 0.14476    |   0.0 |  0.07
Output  | 0.00023397 | 0.00023397 | 0.00023397 |   0.0 |  0.00
Modify  | 0.69891    | 0.69891    | 0.69891    |   0.0 |  0.35
Other   |            | 0.09988    |            |       |  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.18921647233, Press = -0.89332458974956
next a
jump SELF top
variable a loop 2000
run 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   -15365.594   -15365.594   -15504.232   -15504.232    268.20537    268.20537    59559.173    59559.173   -2152.6074   -2152.6074 
   30000   -15364.244   -15364.244   -15504.485   -15504.485    271.30635    271.30635    59459.307    59459.307    965.04351    965.04351 
Loop time of 226.045 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.790 hours/ns, 4.424 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.94     | 224.94     | 224.94     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16554    | 0.16554    | 0.16554    |   0.0 |  0.07
Output  | 0.00025018 | 0.00025018 | 0.00025018 |   0.0 |  0.00
Modify  | 0.83449    | 0.83449    | 0.83449    |   0.0 |  0.37
Other   |            | 0.1081     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.201489890176, Press = -1.69267393173014
next a
jump SELF top
variable a loop 2000
run 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   -15364.244   -15364.244   -15504.485   -15504.485    271.30635    271.30635    59459.307    59459.307    965.04351    965.04351 
   31000   -15362.557   -15362.557   -15502.754   -15502.754    271.22078    271.22078    59509.829    59509.829   -381.52167   -381.52167 
Loop time of 225.845 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.73     | 224.73     | 224.73     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16623    | 0.16623    | 0.16623    |   0.0 |  0.07
Output  | 0.00017952 | 0.00017952 | 0.00017952 |   0.0 |  0.00
Modify  | 0.84084    | 0.84084    | 0.84084    |   0.0 |  0.37
Other   |            | 0.1075     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.142886707276, Press = -0.606141891060627
next a
jump SELF top
variable a loop 2000
run 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.557   -15362.557   -15502.754   -15502.754    271.22078    271.22078    59509.829    59509.829   -381.52167   -381.52167 
   32000   -15364.084   -15364.084   -15505.487   -15505.487     273.5541     273.5541     59494.47     59494.47   -244.17861   -244.17861 
Loop time of 196.367 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.546 hours/ns, 5.093 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.43     | 195.43     | 195.43     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14583    | 0.14583    | 0.14583    |   0.0 |  0.07
Output  | 0.00018119 | 0.00018119 | 0.00018119 |   0.0 |  0.00
Modify  | 0.69279    | 0.69279    | 0.69279    |   0.0 |  0.35
Other   |            | 0.09814    |            |       |  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.137727303251, Press = -1.54976907610248
next a
jump SELF top
variable a loop 2000
run 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   -15364.084   -15364.084   -15505.487   -15505.487     273.5541     273.5541     59494.47     59494.47   -244.17861   -244.17861 
   33000   -15361.244   -15361.244   -15504.396   -15504.396    276.93603    276.93603    59463.315    59463.315    894.55502    894.55502 
Loop time of 225.448 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.34     | 224.34     | 224.34     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16271    | 0.16271    | 0.16271    |   0.0 |  0.07
Output  | 0.00018069 | 0.00018069 | 0.00018069 |   0.0 |  0.00
Modify  | 0.83858    | 0.83858    | 0.83858    |   0.0 |  0.37
Other   |            | 0.1093     |            |       |  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.092947396665, Press = -0.585208626180273
next a
jump SELF top
variable a loop 2000
run 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   -15361.244   -15361.244   -15504.396   -15504.396    276.93603    276.93603    59463.315    59463.315    894.55502    894.55502 
   34000   -15364.327   -15364.327    -15504.22    -15504.22    270.63261    270.63261    59498.275    59498.275   -136.33478   -136.33478 
Loop time of 205.946 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.207 hours/ns, 4.856 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.95     | 204.95     | 204.95     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15101    | 0.15101    | 0.15101    |   0.0 |  0.07
Output  | 0.0001813  | 0.0001813  | 0.0001813  |   0.0 |  0.00
Modify  | 0.73963    | 0.73963    | 0.73963    |   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.053431682072, Press = -2.0084730774405
next a
jump SELF top
variable a loop 2000
run 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   -15364.327   -15364.327    -15504.22    -15504.22    270.63261    270.63261    59498.275    59498.275   -136.33478   -136.33478 
   35000   -15358.912   -15358.912   -15502.562   -15502.562    277.89989    277.89989    59469.689    59469.689    1014.9279    1014.9279 
Loop time of 191.716 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.254 hours/ns, 5.216 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    | 190.81     | 190.81     | 190.81     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14041    | 0.14041    | 0.14041    |   0.0 |  0.07
Output  | 0.00017831 | 0.00017831 | 0.00017831 |   0.0 |  0.00
Modify  | 0.66809    | 0.66809    | 0.66809    |   0.0 |  0.35
Other   |            | 0.0982     |            |       |  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.049398016063, Press = -0.782240936549487
next a
jump SELF top
variable a loop 2000
run 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   -15358.912   -15358.912   -15502.562   -15502.562    277.89989    277.89989    59469.689    59469.689    1014.9279    1014.9279 
   36000   -15363.583   -15363.583   -15504.315   -15504.315    272.25438    272.25438    59530.235    59530.235   -1189.5494   -1189.5494 
Loop time of 213.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.431 hours/ns, 4.674 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.91     | 212.91     | 212.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15433    | 0.15433    | 0.15433    |   0.0 |  0.07
Output  | 0.00028102 | 0.00028102 | 0.00028102 |   0.0 |  0.00
Modify  | 0.77743    | 0.77743    | 0.77743    |   0.0 |  0.36
Other   |            | 0.1053     |            |       |  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.02834896573, Press = -1.6006663192941
next a
jump SELF top
variable a loop 2000
run 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   -15363.583   -15363.583   -15504.315   -15504.315    272.25438    272.25438    59530.235    59530.235   -1189.5494   -1189.5494 
   37000   -15366.597   -15366.597   -15505.809   -15505.809    269.31518    269.31518    59463.816    59463.816    744.77416    744.77416 
Loop time of 224.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.473 hours/ns, 4.446 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.8      | 223.8      | 223.8      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1614     | 0.1614     | 0.1614     |   0.0 |  0.07
Output  | 0.00017961 | 0.00017961 | 0.00017961 |   0.0 |  0.00
Modify  | 0.83364    | 0.83364    | 0.83364    |   0.0 |  0.37
Other   |            | 0.1091     |            |       |  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.039263944372, Press = -0.884898584768466
next a
jump SELF top
variable a loop 2000
run 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   -15366.597   -15366.597   -15505.809   -15505.809    269.31518    269.31518    59463.816    59463.816    744.77416    744.77416 
   38000   -15361.201   -15361.201   -15503.011   -15503.011    274.34017    274.34017    59563.582    59563.582   -2030.7918   -2030.7918 
Loop time of 218.014 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.559 hours/ns, 4.587 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 216.96     | 216.96     | 216.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15679    | 0.15679    | 0.15679    |   0.0 |  0.07
Output  | 0.00017961 | 0.00017961 | 0.00017961 |   0.0 |  0.00
Modify  | 0.79218    | 0.79218    | 0.79218    |   0.0 |  0.36
Other   |            | 0.1066     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 272.993376097751, Press = -0.613496729436208
next a
jump SELF top
variable a loop 2000
run 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   -15361.201   -15361.201   -15503.011   -15503.011    274.34017    274.34017    59563.582    59563.582   -2030.7918   -2030.7918 
   39000   -15361.778   -15361.778   -15503.102   -15503.102    273.40013    273.40013    59429.141    59429.141    2114.2181    2114.2181 
Loop time of 210.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.369 hours/ns, 4.759 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.1      | 209.1      | 209.1      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15342    | 0.15342    | 0.15342    |   0.0 |  0.07
Output  | 0.00017818 | 0.00017818 | 0.00017818 |   0.0 |  0.00
Modify  | 0.76764    | 0.76764    | 0.76764    |   0.0 |  0.37
Other   |            | 0.105      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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.010945481416, Press = -1.98517612398928
next a
jump SELF top
variable a loop 2000
run 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   -15361.778   -15361.778   -15503.102   -15503.102    273.40013    273.40013    59429.141    59429.141    2114.2181    2114.2181 
   40000   -15368.801   -15368.801   -15506.653   -15506.653    266.68383    266.68383     59491.29     59491.29   -347.44593   -347.44593 
Loop time of 224.687 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.58     | 223.58     | 223.58     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1609     | 0.1609     | 0.1609     |   0.0 |  0.07
Output  | 0.00018599 | 0.00018599 | 0.00018599 |   0.0 |  0.00
Modify  | 0.83217    | 0.83217    | 0.83217    |   0.0 |  0.37
Other   |            | 0.1085     |            |       |  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 = 272.963846147184, Press = -0.366322444859038
next a
jump SELF top
variable a loop 2000
run 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   -15368.801   -15368.801   -15506.653   -15506.653    266.68383    266.68383     59491.29     59491.29   -347.44593   -347.44593 
   41000   -15360.895   -15360.895     -15504.3     -15504.3    277.42718    277.42718    59542.852    59542.852   -1715.1217   -1715.1217 
Loop time of 225.175 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.07     | 224.07     | 224.07     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16127    | 0.16127    | 0.16127    |   0.0 |  0.07
Output  | 0.00051598 | 0.00051598 | 0.00051598 |   0.0 |  0.00
Modify  | 0.83232    | 0.83232    | 0.83232    |   0.0 |  0.37
Other   |            | 0.1087     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 272.948005814578, Press = -1.4197699779234
next a
jump SELF top
variable a loop 2000
run 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   -15360.895   -15360.895     -15504.3     -15504.3    277.42718    277.42718    59542.852    59542.852   -1715.1217   -1715.1217 
   42000   -15363.957   -15363.957   -15504.092   -15504.092    271.10087    271.10087    59516.403    59516.403   -804.44055   -804.44055 
Loop time of 224.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.483 hours/ns, 4.446 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.84     | 223.84     | 223.84     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15952    | 0.15952    | 0.15952    |   0.0 |  0.07
Output  | 0.00027327 | 0.00027327 | 0.00027327 |   0.0 |  0.00
Modify  | 0.83013    | 0.83013    | 0.83013    |   0.0 |  0.37
Other   |            | 0.1094     |            |       |  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 = 272.918621334013, Press = -0.579278657560643
next a
jump SELF top
variable a loop 2000
run 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   -15363.957   -15363.957   -15504.092   -15504.092    271.10087    271.10087    59516.403    59516.403   -804.44055   -804.44055 
   43000    -15362.21    -15362.21   -15505.717   -15505.717    277.62374    277.62374    59496.069    59496.069   -253.46908   -253.46908 
Loop time of 224.945 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.485 hours/ns, 4.446 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.84     | 223.84     | 223.84     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16176    | 0.16176    | 0.16176    |   0.0 |  0.07
Output  | 0.00022576 | 0.00022576 | 0.00022576 |   0.0 |  0.00
Modify  | 0.83631    | 0.83631    | 0.83631    |   0.0 |  0.37
Other   |            | 0.1096     |            |       |  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 = 272.903263502232, Press = -1.17759835854328
next a
jump SELF top
variable a loop 2000
run 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    -15362.21    -15362.21   -15505.717   -15505.717    277.62374    277.62374    59496.069    59496.069   -253.46908   -253.46908 
   44000    -15357.84    -15357.84   -15500.699   -15500.699    276.37197    276.37197    59504.437    59504.437    95.604782    95.604782 
Loop time of 225.143 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.04     | 224.04     | 224.04     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16237    | 0.16237    | 0.16237    |   0.0 |  0.07
Output  | 0.00018074 | 0.00018074 | 0.00018074 |   0.0 |  0.00
Modify  | 0.83315    | 0.83315    | 0.83315    |   0.0 |  0.37
Other   |            | 0.1087     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 272.906868015592, Press = -0.280704790751166
next a
jump SELF top
variable a loop 2000
run 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    -15357.84    -15357.84   -15500.699   -15500.699    276.37197    276.37197    59504.437    59504.437    95.604782    95.604782 
   45000   -15364.809   -15364.809   -15503.586   -15503.586    268.47335    268.47335     59514.35     59514.35   -692.10925   -692.10925 
Loop time of 225.147 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.04     | 224.04     | 224.04     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16135    | 0.16135    | 0.16135    |   0.0 |  0.07
Output  | 0.00018407 | 0.00018407 | 0.00018407 |   0.0 |  0.00
Modify  | 0.83325    | 0.83325    | 0.83325    |   0.0 |  0.37
Other   |            | 0.109      |            |       |  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 = 272.939246913747, Press = -2.65565670827479
next a
jump SELF top
variable a loop 2000
run 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   -15364.809   -15364.809   -15503.586   -15503.586    268.47335    268.47335     59514.35     59514.35   -692.10925   -692.10925 
   46000   -15361.425   -15361.425   -15503.979   -15503.979    275.77871    275.77871    59497.274    59497.274   -90.921362   -90.921362 
Loop time of 224.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.463 hours/ns, 4.447 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.76     | 223.76     | 223.76     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16119    | 0.16119    | 0.16119    |   0.0 |  0.07
Output  | 0.00017824 | 0.00017824 | 0.00017824 |   0.0 |  0.00
Modify  | 0.8379     | 0.8379     | 0.8379     |   0.0 |  0.37
Other   |            | 0.1095     |            |       |  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 = 272.910209032025, Press = 0.227608744748151
next a
jump SELF top
variable a loop 2000
run 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   -15361.425   -15361.425   -15503.979   -15503.979    275.77871    275.77871    59497.274    59497.274   -90.921362   -90.921362 
   47000    -15366.85    -15366.85   -15505.556   -15505.556    268.33623    268.33623    59529.889    59529.889   -1338.3419   -1338.3419 
Loop time of 224.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.463 hours/ns, 4.447 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.76     | 223.76     | 223.76     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16173    | 0.16173    | 0.16173    |   0.0 |  0.07
Output  | 0.00018011 | 0.00018011 | 0.00018011 |   0.0 |  0.00
Modify  | 0.8384     | 0.8384     | 0.8384     |   0.0 |  0.37
Other   |            | 0.1099     |            |       |  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 = 272.901736969811, Press = -0.703230430893838
next a
jump SELF top
variable a loop 2000
run 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    -15366.85    -15366.85   -15505.556   -15505.556    268.33623    268.33623    59529.889    59529.889   -1338.3419   -1338.3419 
   48000   -15362.131   -15362.131   -15499.622   -15499.622    265.98719    265.98719    59471.368    59471.368    1197.5359    1197.5359 
Loop time of 225.193 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.08     | 224.08     | 224.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16275    | 0.16275    | 0.16275    |   0.0 |  0.07
Output  | 0.00018168 | 0.00018168 | 0.00018168 |   0.0 |  0.00
Modify  | 0.83611    | 0.83611    | 0.83611    |   0.0 |  0.37
Other   |            | 0.1098     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 272.878481239909, Press = -0.924202063228586
next a
jump SELF top
variable a loop 2000
run 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   -15362.131   -15362.131   -15499.622   -15499.622    265.98719    265.98719    59471.368    59471.368    1197.5359    1197.5359 
   49000   -15363.267   -15363.267   -15504.178   -15504.178     272.6013     272.6013    59545.947    59545.947   -1736.2043   -1736.2043 
Loop time of 211.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.692 hours/ns, 4.733 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    | 210.27     | 210.27     | 210.27     |   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.00018209 | 0.00018209 | 0.00018209 |   0.0 |  0.00
Modify  | 0.7659     | 0.7659     | 0.7659     |   0.0 |  0.36
Other   |            | 0.1042     |            |       |  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 = 272.891531359624, Press = -1.29414076630426
next a
jump SELF top
variable a loop 2000
run 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.267   -15363.267   -15504.178   -15504.178     272.6013     272.6013    59545.947    59545.947   -1736.2043   -1736.2043 
   50000   -15357.277   -15357.277   -15501.241   -15501.241    278.50881    278.50881    59485.187    59485.187    678.10472    678.10472 
Loop time of 225.425 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.32     | 224.32     | 224.32     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16202    | 0.16202    | 0.16202    |   0.0 |  0.07
Output  | 0.00029895 | 0.00029895 | 0.00029895 |   0.0 |  0.00
Modify  | 0.83778    | 0.83778    | 0.83778    |   0.0 |  0.37
Other   |            | 0.1093     |            |       |  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 = 272.91466790194, Press = -0.704915577616908
next a
jump SELF top
variable a loop 2000
run 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   -15357.277   -15357.277   -15501.241   -15501.241    278.50881    278.50881    59485.187    59485.187    678.10472    678.10472 
   51000    -15361.27    -15361.27   -15501.989   -15501.989     272.2303     272.2303    59505.535    59505.535   -206.88188   -206.88188 
Loop time of 195.734 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.370 hours/ns, 5.109 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    | 194.8      | 194.8      | 194.8      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14601    | 0.14601    | 0.14601    |   0.0 |  0.07
Output  | 0.00018123 | 0.00018123 | 0.00018123 |   0.0 |  0.00
Modify  | 0.68612    | 0.68612    | 0.68612    |   0.0 |  0.35
Other   |            | 0.09696    |            |       |  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 = 272.908972992689, Press = -0.0854467003110153
next a
jump SELF top
variable a loop 2000
run 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    -15361.27    -15361.27   -15501.989   -15501.989     272.2303     272.2303    59505.535    59505.535   -206.88188   -206.88188 
   52000   -15364.471   -15364.471   -15501.679   -15501.679    265.43643    265.43643    59459.786    59459.786    1342.5067    1342.5067 
Loop time of 206.054 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.237 hours/ns, 4.853 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.06     | 205.06     | 205.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15083    | 0.15083    | 0.15083    |   0.0 |  0.07
Output  | 0.00028004 | 0.00028004 | 0.00028004 |   0.0 |  0.00
Modify  | 0.73768    | 0.73768    | 0.73768    |   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:      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 = 272.885473431973, Press = -0.909556228847625
next a
jump SELF top
variable a loop 2000
run 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   -15364.471   -15364.471   -15501.679   -15501.679    265.43643    265.43643    59459.786    59459.786    1342.5067    1342.5067 
   53000   -15360.384   -15360.384   -15501.054   -15501.054    272.13493    272.13493    59495.828    59495.828    148.39148    148.39148 
Loop time of 204.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.693 hours/ns, 4.900 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.11     | 203.11     | 203.11     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14936    | 0.14936    | 0.14936    |   0.0 |  0.07
Output  | 0.00018202 | 0.00018202 | 0.00018202 |   0.0 |  0.00
Modify  | 0.73316    | 0.73316    | 0.73316    |   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:      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 = 272.883121136873, Press = -0.38206270830552
next a
jump SELF top
variable a loop 2000
run 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.384   -15360.384   -15501.054   -15501.054    272.13493    272.13493    59495.828    59495.828    148.39148    148.39148 
   54000   -15365.661   -15365.661    -15505.26    -15505.26    270.06454    270.06454    59464.944    59464.944    565.96716    565.96716 
Loop time of 225.222 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.11     | 224.11     | 224.11     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16271    | 0.16271    | 0.16271    |   0.0 |  0.07
Output  | 0.00017951 | 0.00017951 | 0.00017951 |   0.0 |  0.00
Modify  | 0.83459    | 0.83459    | 0.83459    |   0.0 |  0.37
Other   |            | 0.1099     |            |       |  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 = 272.909927625302, Press = -1.23982477871522
next a
jump SELF top
variable a loop 2000
run 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   -15365.661   -15365.661    -15505.26    -15505.26    270.06454    270.06454    59464.944    59464.944    565.96716    565.96716 
   55000    -15359.81    -15359.81   -15502.957   -15502.957    276.92741    276.92741    59492.562    59492.562    97.632075    97.632075 
Loop time of 224.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.395 hours/ns, 4.452 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.52     | 223.52     | 223.52     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16204    | 0.16204    | 0.16204    |   0.0 |  0.07
Output  | 0.00018086 | 0.00018086 | 0.00018086 |   0.0 |  0.00
Modify  | 0.83321    | 0.83321    | 0.83321    |   0.0 |  0.37
Other   |            | 0.1091     |            |       |  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 = 272.94239191392, Press = -0.20398138206636
next a
jump SELF top
variable a loop 2000
run 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    -15359.81    -15359.81   -15502.957   -15502.957    276.92741    276.92741    59492.562    59492.562    97.632075    97.632075 
   56000   -15361.313   -15361.313   -15503.455   -15503.455    274.98452    274.98452    59541.067    59541.067   -1501.2384   -1501.2384 
Loop time of 193.594 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.446 ns/day, 53.776 hours/ns, 5.165 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.68     | 192.68     | 192.68     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1446     | 0.1446     | 0.1446     |   0.0 |  0.07
Output  | 0.00018154 | 0.00018154 | 0.00018154 |   0.0 |  0.00
Modify  | 0.67419    | 0.67419    | 0.67419    |   0.0 |  0.35
Other   |            | 0.09667    |            |       |  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 = 272.957804295842, Press = -1.04163999195542
next a
jump SELF top
variable a loop 2000
run 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   -15361.313   -15361.313   -15503.455   -15503.455    274.98452    274.98452    59541.067    59541.067   -1501.2384   -1501.2384 
   57000   -15362.066   -15362.066    -15502.23    -15502.23    271.15704    271.15704    59469.367    59469.367    933.34583    933.34583 
Loop time of 196.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.713 hours/ns, 5.077 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.02     | 196.02     | 196.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1458     | 0.1458     | 0.1458     |   0.0 |  0.07
Output  | 0.00017837 | 0.00017837 | 0.00017837 |   0.0 |  0.00
Modify  | 0.69816    | 0.69816    | 0.69816    |   0.0 |  0.35
Other   |            | 0.09975    |            |       |  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 = 272.959242694763, Press = -0.679195436035932
next a
jump SELF top
variable a loop 2000
run 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.066   -15362.066    -15502.23    -15502.23    271.15704    271.15704    59469.367    59469.367    933.34583    933.34583 
   58000   -15359.107   -15359.107   -15501.031   -15501.031    274.56165    274.56165    59496.002    59496.002    231.75849    231.75849 
Loop time of 203.846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.624 hours/ns, 4.906 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.86     | 202.86     | 202.86     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14759    | 0.14759    | 0.14759    |   0.0 |  0.07
Output  | 0.00022365 | 0.00022365 | 0.00022365 |   0.0 |  0.00
Modify  | 0.73276    | 0.73276    | 0.73276    |   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:      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"
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
59494.7069496985

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0