# 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.889087237417698*${_u_distance}
variable latticeconst_converted equal 3.889087237417698*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.8890872374177
Lattice spacing in x,y,z = 3.8890872 3.8890872 3.8890872
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.890872 38.890872 38.890872)
  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.890872 38.890872 38.890872)
  create_atoms CPU = 0.005 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_KoLee_2013_VPdY__MO_046547823135_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.4426779163    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 58822.4426779163/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 58822.4426779163/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 58822.4426779163/(1*1*${_u_distance})
variable      V0_metal equal 58822.4426779163/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 58822.4426779163*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 58822.4426779163 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_046547823135_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.443    58822.443    2563.8912    2563.8912 
    1000   -15358.613   -15358.613   -15499.149   -15499.149    271.87599    271.87599     59526.62     59526.62   -630.52914   -630.52914 
Loop time of 421.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.112 hours/ns, 2.372 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 420.54     | 420.54     | 420.54     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20984    | 0.20984    | 0.20984    |   0.0 |  0.05
Output  | 0.00032343 | 0.00032343 | 0.00032343 |   0.0 |  0.00
Modify  | 0.74899    | 0.74899    | 0.74899    |   0.0 |  0.18
Other   |            | 0.1057     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      560000.0 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 560000
Ave neighs/atom = 140.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.52914   -630.52914 
    2000   -15361.482   -15361.482   -15501.463   -15501.463    270.80155    270.80155    59455.883    59455.883    1331.0029    1331.0029 
Loop time of 459.776 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.716 hours/ns, 2.175 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 458.64     | 458.64     | 458.64     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21856    | 0.21856    | 0.21856    |   0.0 |  0.05
Output  | 0.00025522 | 0.00025522 | 0.00025522 |   0.0 |  0.00
Modify  | 0.80298    | 0.80298    | 0.80298    |   0.0 |  0.17
Other   |            | 0.1099     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559510.0 ave      559510 max      559510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559510
Ave neighs/atom = 139.87750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.0029    1331.0029 
    3000   -15365.649   -15365.649   -15503.333   -15503.333    266.35891    266.35891     59551.88     59551.88    -1897.531    -1897.531 
Loop time of 445.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.872 hours/ns, 2.242 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 444.85     | 444.85     | 444.85     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21261    | 0.21261    | 0.21261    |   0.0 |  0.05
Output  | 0.00021817 | 0.00021817 | 0.00021817 |   0.0 |  0.00
Modify  | 0.76884    | 0.76884    | 0.76884    |   0.0 |  0.17
Other   |            | 0.1068     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559706.0 ave      559706 max      559706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559706
Ave neighs/atom = 139.92650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.531    -1897.531 
    4000   -15357.776   -15357.776   -15503.221   -15503.221    281.37341    281.37341    59529.217    59529.217   -916.95553   -916.95553 
Loop time of 390.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.573 hours/ns, 2.558 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.93     | 389.93     | 389.93     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19468    | 0.19468    | 0.19468    |   0.0 |  0.05
Output  | 0.00025393 | 0.00025393 | 0.00025393 |   0.0 |  0.00
Modify  | 0.64326    | 0.64326    | 0.64326    |   0.0 |  0.16
Other   |            | 0.0974     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8182.00 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559592.0 ave      559592 max      559592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559592
Ave neighs/atom = 139.89800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.95553   -916.95553 
    5000   -15364.683   -15364.683   -15508.087   -15508.087    277.42615    277.42615    59445.262    59445.262    1031.6985    1031.6985 
Loop time of 435.194 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.887 hours/ns, 2.298 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 434.13     | 434.13     | 434.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20973    | 0.20973    | 0.20973    |   0.0 |  0.05
Output  | 0.00022345 | 0.00022345 | 0.00022345 |   0.0 |  0.00
Modify  | 0.74737    | 0.74737    | 0.74737    |   0.0 |  0.17
Other   |            | 0.1054     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8192.00 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559692.0 ave      559692 max      559692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559692
Ave neighs/atom = 139.92300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.730876587759, Press = -979.114742188236
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.42615    277.42615    59445.262    59445.262    1031.6985    1031.6985 
    6000    -15360.94    -15360.94   -15502.954   -15502.954    274.73738    274.73738    59480.341    59480.341    518.01414    518.01414 
Loop time of 444.431 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.453 hours/ns, 2.250 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    | 443.32     | 443.32     | 443.32     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2142     | 0.2142     | 0.2142     |   0.0 |  0.05
Output  | 0.00017788 | 0.00017788 | 0.00017788 |   0.0 |  0.00
Modify  | 0.7889     | 0.7889     | 0.7889     |   0.0 |  0.18
Other   |            | 0.1061     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8188.00 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559734.0 ave      559734 max      559734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559734
Ave neighs/atom = 139.93350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.121543298226, Press = -3.0237307236201
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.01414    518.01414 
    7000   -15362.909   -15362.909   -15502.534   -15502.534    270.11489    270.11489     59468.89     59468.89    914.25894    914.25894 
Loop time of 462.643 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.512 hours/ns, 2.161 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    | 461.48     | 461.48     | 461.48     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21907    | 0.21907    | 0.21907    |   0.0 |  0.05
Output  | 0.00029893 | 0.00029893 | 0.00029893 |   0.0 |  0.00
Modify  | 0.83581    | 0.83581    | 0.83581    |   0.0 |  0.18
Other   |            | 0.1104     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559640.0 ave      559640 max      559640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559640
Ave neighs/atom = 139.91000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.904852289453, Press = -14.2648791273751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.25894    914.25894 
    8000   -15367.213   -15367.213   -15505.773   -15505.773    268.05404    268.05404    59475.984    59475.984    227.46088    227.46088 
Loop time of 404.237 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.288 hours/ns, 2.474 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 403.24     | 403.24     | 403.24     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20011    | 0.20011    | 0.20011    |   0.0 |  0.05
Output  | 0.00022243 | 0.00022243 | 0.00022243 |   0.0 |  0.00
Modify  | 0.70288    | 0.70288    | 0.70288    |   0.0 |  0.17
Other   |            | 0.09861    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8181.00 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559650.0 ave      559650 max      559650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.188 ns/day, 127.968 hours/ns, 2.171 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 459.52     | 459.52     | 459.52     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22209    | 0.22209    | 0.22209    |   0.0 |  0.05
Output  | 0.00018211 | 0.00018211 | 0.00018211 |   0.0 |  0.00
Modify  | 0.83338    | 0.83338    | 0.83338    |   0.0 |  0.18
Other   |            | 0.11       |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559680.0 ave      559680 max      559680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559680
Ave neighs/atom = 139.92000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.839565691421, Press = -12.9231386931236
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.15149    273.15149    59524.679    59524.679   -686.46309   -686.46309 
   10000   -15362.534   -15362.534   -15504.009   -15504.009    273.69262    273.69262    59476.618    59476.618    590.29818    590.29818 
Loop time of 432.11 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.031 hours/ns, 2.314 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 431.03     | 431.03     | 431.03     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2092     | 0.2092     | 0.2092     |   0.0 |  0.05
Output  | 0.0001786  | 0.0001786  | 0.0001786  |   0.0 |  0.00
Modify  | 0.76506    | 0.76506    | 0.76506    |   0.0 |  0.18
Other   |            | 0.1055     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8178.00 ave        8178 max        8178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559552.0 ave      559552 max      559552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559552
Ave neighs/atom = 139.88800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.357653481279, Press = -9.61095329211691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.69262    273.69262    59476.618    59476.618    590.29818    590.29818 
   11000   -15358.117   -15358.117   -15502.265   -15502.265     278.8643     278.8643    59538.164    59538.164   -1173.9331   -1173.9331 
Loop time of 419.723 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.590 hours/ns, 2.383 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    | 418.69     | 418.69     | 418.69     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20438    | 0.20438    | 0.20438    |   0.0 |  0.05
Output  | 0.00018318 | 0.00018318 | 0.00018318 |   0.0 |  0.00
Modify  | 0.7297     | 0.7297     | 0.7297     |   0.0 |  0.17
Other   |            | 0.1013     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559648.0 ave      559648 max      559648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559648
Ave neighs/atom = 139.91200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.390456182835, Press = 1.01242432662162
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 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.8643     278.8643    59538.164    59538.164   -1173.9331   -1173.9331 
   12000   -15363.051   -15363.051   -15504.778   -15504.778     274.1806     274.1806    59501.221    59501.221    -344.0004    -344.0004 
Loop time of 400.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.256 hours/ns, 2.497 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 399.53     | 399.53     | 399.53     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19886    | 0.19886    | 0.19886    |   0.0 |  0.05
Output  | 0.00021875 | 0.00021875 | 0.00021875 |   0.0 |  0.00
Modify  | 0.69096    | 0.69096    | 0.69096    |   0.0 |  0.17
Other   |            | 0.09868    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559538.0 ave      559538 max      559538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559538
Ave neighs/atom = 139.88450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.26896638145, Press = -9.1185549985766
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -15363.051   -15363.051   -15504.778   -15504.778     274.1806     274.1806    59501.221    59501.221    -344.0004    -344.0004 
   13000   -15362.616   -15362.616   -15502.456   -15502.456    270.53023    270.53023    59477.425    59477.425    645.11254    645.11254 
Loop time of 404.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.251 hours/ns, 2.475 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 403.11     | 403.11     | 403.11     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20031    | 0.20031    | 0.20031    |   0.0 |  0.05
Output  | 0.00017798 | 0.00017798 | 0.00017798 |   0.0 |  0.00
Modify  | 0.69613    | 0.69613    | 0.69613    |   0.0 |  0.17
Other   |            | 0.09874    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559650.0 ave      559650 max      559650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559650
Ave neighs/atom = 139.91250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.259494441729, Press = -0.553747501565659
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -15362.616   -15362.616   -15502.456   -15502.456    270.53023    270.53023    59477.425    59477.425    645.11254    645.11254 
   14000    -15355.87    -15355.87   -15499.247   -15499.247     277.3722     277.3722    59529.719    59529.719   -556.48128   -556.48128 
Loop time of 391.769 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.825 hours/ns, 2.553 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.81     | 390.81     | 390.81     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19475    | 0.19475    | 0.19475    |   0.0 |  0.05
Output  | 0.00017926 | 0.00017926 | 0.00017926 |   0.0 |  0.00
Modify  | 0.66894    | 0.66894    | 0.66894    |   0.0 |  0.17
Other   |            | 0.09726    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559654.0 ave      559654 max      559654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559654
Ave neighs/atom = 139.91350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.239782693548, Press = -4.37167950332764
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -15355.87    -15355.87   -15499.247   -15499.247     277.3722     277.3722    59529.719    59529.719   -556.48128   -556.48128 
   15000   -15364.021   -15364.021   -15504.158   -15504.158    271.10485    271.10485     59494.11     59494.11   -93.511131   -93.511131 
Loop time of 391.335 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.704 hours/ns, 2.555 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.38     | 390.38     | 390.38     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19456    | 0.19456    | 0.19456    |   0.0 |  0.05
Output  | 0.00017778 | 0.00017778 | 0.00017778 |   0.0 |  0.00
Modify  | 0.66909    | 0.66909    | 0.66909    |   0.0 |  0.17
Other   |            | 0.09604    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559560.0 ave      559560 max      559560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559560
Ave neighs/atom = 139.89000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.306462496105, Press = -2.18715916704881
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -15364.021   -15364.021   -15504.158   -15504.158    271.10485    271.10485     59494.11     59494.11   -93.511131   -93.511131 
   16000   -15359.712   -15359.712   -15501.082   -15501.082    273.49048    273.49048    59544.779    59544.779   -1229.1721   -1229.1721 
Loop time of 391.463 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.740 hours/ns, 2.555 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.5      | 390.5      | 390.5      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19462    | 0.19462    | 0.19462    |   0.0 |  0.05
Output  | 0.00017852 | 0.00017852 | 0.00017852 |   0.0 |  0.00
Modify  | 0.66764    | 0.66764    | 0.66764    |   0.0 |  0.17
Other   |            | 0.09646    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559632.0 ave      559632 max      559632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559632
Ave neighs/atom = 139.90800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.474520834487, Press = -4.38165982063883
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -15359.712   -15359.712   -15501.082   -15501.082    273.49048    273.49048    59544.779    59544.779   -1229.1721   -1229.1721 
   17000   -15364.339   -15364.339   -15504.697   -15504.697    271.53245    271.53245    59482.191    59482.191    255.02476    255.02476 
Loop time of 400.411 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.225 hours/ns, 2.497 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 399.42     | 399.42     | 399.42     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19862    | 0.19862    | 0.19862    |   0.0 |  0.05
Output  | 0.00017904 | 0.00017904 | 0.00017904 |   0.0 |  0.00
Modify  | 0.69097    | 0.69097    | 0.69097    |   0.0 |  0.17
Other   |            | 0.09788    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8187.00 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559540.0 ave      559540 max      559540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559540
Ave neighs/atom = 139.88500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.416864724643, Press = -0.62704290731335
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -15364.339   -15364.339   -15504.697   -15504.697    271.53245    271.53245    59482.191    59482.191    255.02476    255.02476 
   18000   -15360.917   -15360.917   -15503.308   -15503.308    275.46501    275.46501    59534.464    59534.464   -1259.7589   -1259.7589 
Loop time of 398.218 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.616 hours/ns, 2.511 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 397.23     | 397.23     | 397.23     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19957    | 0.19957    | 0.19957    |   0.0 |  0.05
Output  | 0.00017867 | 0.00017867 | 0.00017867 |   0.0 |  0.00
Modify  | 0.68477    | 0.68477    | 0.68477    |   0.0 |  0.17
Other   |            | 0.09907    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559650.0 ave      559650 max      559650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559650
Ave neighs/atom = 139.91250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.457120011671, Press = -3.49781715845613
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -15360.917   -15360.917   -15503.308   -15503.308    275.46501    275.46501    59534.464    59534.464   -1259.7589   -1259.7589 
   19000    -15361.81    -15361.81   -15505.556   -15505.556    278.08784    278.08784    59438.204    59438.204    1668.4632    1668.4632 
Loop time of 430.851 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.681 hours/ns, 2.321 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 429.78     | 429.78     | 429.78     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20802    | 0.20802    | 0.20802    |   0.0 |  0.05
Output  | 0.0001791  | 0.0001791  | 0.0001791  |   0.0 |  0.00
Modify  | 0.76025    | 0.76025    | 0.76025    |   0.0 |  0.18
Other   |            | 0.1047     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8194.00 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559536.0 ave      559536 max      559536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559536
Ave neighs/atom = 139.88400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.424961954275, Press = -2.3124459490275
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -15361.81    -15361.81   -15505.556   -15505.556    278.08784    278.08784    59438.204    59438.204    1668.4632    1668.4632 
   20000   -15358.219   -15358.219   -15502.763   -15502.763    279.63093    279.63093    59536.013    59536.013   -1223.0797   -1223.0797 
Loop time of 453.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.859 hours/ns, 2.207 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    | 451.96     | 451.96     | 451.96     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21638    | 0.21638    | 0.21638    |   0.0 |  0.05
Output  | 0.00022507 | 0.00022507 | 0.00022507 |   0.0 |  0.00
Modify  | 0.80952    | 0.80952    | 0.80952    |   0.0 |  0.18
Other   |            | 0.1088     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559688.0 ave      559688 max      559688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559688
Ave neighs/atom = 139.92200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.542657211583, Press = -1.22561958886525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -15358.219   -15358.219   -15502.763   -15502.763    279.63093    279.63093    59536.013    59536.013   -1223.0797   -1223.0797 
   21000   -15362.087   -15362.087    -15505.35    -15505.35    277.15125    277.15125    59515.307    59515.307   -784.91723   -784.91723 
Loop time of 443.817 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 123.283 hours/ns, 2.253 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 442.69     | 442.69     | 442.69     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21447    | 0.21447    | 0.21447    |   0.0 |  0.05
Output  | 0.00018598 | 0.00018598 | 0.00018598 |   0.0 |  0.00
Modify  | 0.8002     | 0.8002     | 0.8002     |   0.0 |  0.18
Other   |            | 0.1084     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559568.0 ave      559568 max      559568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559568
Ave neighs/atom = 139.89200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.523899828366, Press = -5.70215363418819
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -15362.087   -15362.087    -15505.35    -15505.35    277.15125    277.15125    59515.307    59515.307   -784.91723   -784.91723 
   22000   -15362.518   -15362.518    -15504.47    -15504.47    274.61407    274.61407    59472.077    59472.077    691.41173    691.41173 
Loop time of 446.052 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.903 hours/ns, 2.242 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    | 444.93     | 444.93     | 444.93     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21485    | 0.21485    | 0.21485    |   0.0 |  0.05
Output  | 0.00022862 | 0.00022862 | 0.00022862 |   0.0 |  0.00
Modify  | 0.79629    | 0.79629    | 0.79629    |   0.0 |  0.18
Other   |            | 0.1072     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8190.00 ave        8190 max        8190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559624.0 ave      559624 max      559624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559624
Ave neighs/atom = 139.90600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.579862471147, Press = 0.147153729685467
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -15362.518   -15362.518    -15504.47    -15504.47    274.61407    274.61407    59472.077    59472.077    691.41173    691.41173 
   23000   -15357.272   -15357.272   -15500.062   -15500.062    276.23631    276.23631    59502.826    59502.826    167.49941    167.49941 
Loop time of 461.892 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.303 hours/ns, 2.165 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    | 460.73     | 460.73     | 460.73     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22107    | 0.22107    | 0.22107    |   0.0 |  0.05
Output  | 0.00017594 | 0.00017594 | 0.00017594 |   0.0 |  0.00
Modify  | 0.83492    | 0.83492    | 0.83492    |   0.0 |  0.18
Other   |            | 0.1103     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8187.00 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559682.0 ave      559682 max      559682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559682
Ave neighs/atom = 139.92050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.604802212829, Press = -2.74177157909645
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -15357.272   -15357.272   -15500.062   -15500.062    276.23631    276.23631    59502.826    59502.826    167.49941    167.49941 
   24000   -15362.051   -15362.051   -15503.553   -15503.553    273.74639    273.74639    59476.306    59476.306    647.45403    647.45403 
Loop time of 428.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.120 hours/ns, 2.332 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    | 427.76     | 427.76     | 427.76     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20854    | 0.20854    | 0.20854    |   0.0 |  0.05
Output  | 0.00022191 | 0.00022191 | 0.00022191 |   0.0 |  0.00
Modify  | 0.76012    | 0.76012    | 0.76012    |   0.0 |  0.18
Other   |            | 0.1054     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8180.00 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559618.0 ave      559618 max      559618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559618
Ave neighs/atom = 139.90450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.615550668592, Press = -2.00654268895201
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -15362.051   -15362.051   -15503.553   -15503.553    273.74639    273.74639    59476.306    59476.306    647.45403    647.45403 
   25000   -15360.336   -15360.336   -15502.063   -15502.063    274.18091    274.18091    59467.879    59467.879    1038.3329    1038.3329 
Loop time of 461.816 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.282 hours/ns, 2.165 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    | 460.66     | 460.66     | 460.66     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21985    | 0.21985    | 0.21985    |   0.0 |  0.05
Output  | 0.00018882 | 0.00018882 | 0.00018882 |   0.0 |  0.00
Modify  | 0.82313    | 0.82313    | 0.82313    |   0.0 |  0.18
Other   |            | 0.1101     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559672.0 ave      559672 max      559672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559672
Ave neighs/atom = 139.91800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.650629997157, Press = -0.672607850202783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -15360.336   -15360.336   -15502.063   -15502.063    274.18091    274.18091    59467.879    59467.879    1038.3329    1038.3329 
   26000   -15364.343   -15364.343   -15504.767   -15504.767     271.6611     271.6611    59526.786    59526.786   -1164.4545   -1164.4545 
Loop time of 454.326 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.202 hours/ns, 2.201 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 453.19     | 453.19     | 453.19     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21594    | 0.21594    | 0.21594    |   0.0 |  0.05
Output  | 0.00022467 | 0.00022467 | 0.00022467 |   0.0 |  0.00
Modify  | 0.8124     | 0.8124     | 0.8124     |   0.0 |  0.18
Other   |            | 0.1091     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8180.00 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559664.0 ave      559664 max      559664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559664
Ave neighs/atom = 139.91600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.583852155367, Press = -1.45788714438689
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -15364.343   -15364.343   -15504.767   -15504.767     271.6611     271.6611    59526.786    59526.786   -1164.4545   -1164.4545 
   27000   -15367.885   -15367.885   -15507.008   -15507.008    269.14156    269.14156    59446.928    59446.928    1160.6955    1160.6955 
Loop time of 449.073 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.742 hours/ns, 2.227 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    | 447.94     | 447.94     | 447.94     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21603    | 0.21603    | 0.21603    |   0.0 |  0.05
Output  | 0.0002426  | 0.0002426  | 0.0002426  |   0.0 |  0.00
Modify  | 0.80789    | 0.80789    | 0.80789    |   0.0 |  0.18
Other   |            | 0.1072     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8190.00 ave        8190 max        8190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559574.0 ave      559574 max      559574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559574
Ave neighs/atom = 139.89350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.552721128921, Press = -2.08956234347725
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -15367.885   -15367.885   -15507.008   -15507.008    269.14156    269.14156    59446.928    59446.928    1160.6955    1160.6955 
   28000   -15360.278   -15360.278   -15502.756   -15502.756    275.63311    275.63311    59495.615    59495.615    187.31629    187.31629 
Loop time of 442.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 122.823 hours/ns, 2.262 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    | 441.05     | 441.05     | 441.05     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21263    | 0.21263    | 0.21263    |   0.0 |  0.05
Output  | 0.00018115 | 0.00018115 | 0.00018115 |   0.0 |  0.00
Modify  | 0.79059    | 0.79059    | 0.79059    |   0.0 |  0.18
Other   |            | 0.1068     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8192.00 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559726.0 ave      559726 max      559726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559726
Ave neighs/atom = 139.93150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.469833639192, Press = -0.222233649360393
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -15360.278   -15360.278   -15502.756   -15502.756    275.63311    275.63311    59495.615    59495.615    187.31629    187.31629 
   29000   -15364.603   -15364.603   -15504.427   -15504.427    270.49916    270.49916    59543.728    59543.728   -1682.9253   -1682.9253 
Loop time of 431.878 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.966 hours/ns, 2.315 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    | 430.8      | 430.8      | 430.8      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21       | 0.21       | 0.21       |   0.0 |  0.05
Output  | 0.00022221 | 0.00022221 | 0.00022221 |   0.0 |  0.00
Modify  | 0.7669     | 0.7669     | 0.7669     |   0.0 |  0.18
Other   |            | 0.1059     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559614.0 ave      559614 max      559614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559614
Ave neighs/atom = 139.90350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.411341369155, Press = -1.5112263747085
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -15364.603   -15364.603   -15504.427   -15504.427    270.49916    270.49916    59543.728    59543.728   -1682.9253   -1682.9253 
   30000    -15362.52    -15362.52   -15503.372   -15503.372    272.48651    272.48651    59448.655    59448.655    1453.6268    1453.6268 
Loop time of 456.718 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 126.866 hours/ns, 2.190 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    | 455.56     | 455.56     | 455.56     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2191     | 0.2191     | 0.2191     |   0.0 |  0.05
Output  | 0.00028918 | 0.00028918 | 0.00028918 |   0.0 |  0.00
Modify  | 0.82747    | 0.82747    | 0.82747    |   0.0 |  0.18
Other   |            | 0.1102     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559560.0 ave      559560 max      559560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559560
Ave neighs/atom = 139.89000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.457287734828, Press = -1.21474808931276
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    -15362.52    -15362.52   -15503.372   -15503.372    272.48651    272.48651    59448.655    59448.655    1453.6268    1453.6268 
   31000   -15359.796   -15359.796   -15501.075   -15501.075    273.31349    273.31349    59534.012    59534.012   -916.52562   -916.52562 
Loop time of 411.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.269 hours/ns, 2.431 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 410.34     | 410.34     | 410.34     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2031     | 0.2031     | 0.2031     |   0.0 |  0.05
Output  | 0.00017969 | 0.00017969 | 0.00017969 |   0.0 |  0.00
Modify  | 0.7187     | 0.7187     | 0.7187     |   0.0 |  0.17
Other   |            | 0.1021     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559550.0 ave      559550 max      559550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559550
Ave neighs/atom = 139.88750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.492332403159, Press = -0.534352493724689
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -15359.796   -15359.796   -15501.075   -15501.075    273.31349    273.31349    59534.012    59534.012   -916.52562   -916.52562 
   32000   -15364.569   -15364.569   -15505.522   -15505.522    272.68258    272.68258    59487.386    59487.386   -7.5167182   -7.5167182 
Loop time of 461.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.077 hours/ns, 2.169 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 459.91     | 459.91     | 459.91     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21912    | 0.21912    | 0.21912    |   0.0 |  0.05
Output  | 0.00017739 | 0.00017739 | 0.00017739 |   0.0 |  0.00
Modify  | 0.83183    | 0.83183    | 0.83183    |   0.0 |  0.18
Other   |            | 0.1107     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559586.0 ave      559586 max      559586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559586
Ave neighs/atom = 139.89650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.511890655154, Press = -2.26265587817648
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -15364.569   -15364.569   -15505.522   -15505.522    272.68258    272.68258    59487.386    59487.386   -7.5167182   -7.5167182 
   33000   -15358.603   -15358.603   -15503.042   -15503.042    279.42863    279.42863    59431.498    59431.498    2140.5564    2140.5564 
Loop time of 429.834 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.398 hours/ns, 2.326 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    | 428.76     | 428.76     | 428.76     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20832    | 0.20832    | 0.20832    |   0.0 |  0.05
Output  | 0.00017994 | 0.00017994 | 0.00017994 |   0.0 |  0.00
Modify  | 0.75795    | 0.75795    | 0.75795    |   0.0 |  0.18
Other   |            | 0.1046     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8188.00 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559648.0 ave      559648 max      559648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559648
Ave neighs/atom = 139.91200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.531292709002, Press = 0.668317740158266
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -15358.603   -15358.603   -15503.042   -15503.042    279.42863    279.42863    59431.498    59431.498    2140.5564    2140.5564 
   34000   -15367.321   -15367.321   -15506.593   -15506.593    269.42968    269.42968     59502.66     59502.66    -590.4407    -590.4407 
Loop time of 390.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.595 hours/ns, 2.558 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.98     | 389.98     | 389.98     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19532    | 0.19532    | 0.19532    |   0.0 |  0.05
Output  | 0.00018315 | 0.00018315 | 0.00018315 |   0.0 |  0.00
Modify  | 0.66999    | 0.66999    | 0.66999    |   0.0 |  0.17
Other   |            | 0.09741    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8194.00 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559664.0 ave      559664 max      559664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559664
Ave neighs/atom = 139.91600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.483205504587, Press = -1.85746797183137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -15367.321   -15367.321   -15506.593   -15506.593    269.42968    269.42968     59502.66     59502.66    -590.4407    -590.4407 
   35000    -15364.37    -15364.37   -15505.306   -15505.306    272.64988    272.64988    59471.134    59471.134    636.46415    636.46415 
Loop time of 391.121 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.645 hours/ns, 2.557 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.16     | 390.16     | 390.16     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19528    | 0.19528    | 0.19528    |   0.0 |  0.05
Output  | 0.00018465 | 0.00018465 | 0.00018465 |   0.0 |  0.00
Modify  | 0.67032    | 0.67032    | 0.67032    |   0.0 |  0.17
Other   |            | 0.09773    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8188.00 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559626.0 ave      559626 max      559626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559626
Ave neighs/atom = 139.90650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.467183763371, Press = -1.07822983997323
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -15364.37    -15364.37   -15505.306   -15505.306    272.64988    272.64988    59471.134    59471.134    636.46415    636.46415 
   36000   -15356.271   -15356.271   -15501.735   -15501.735    281.40939    281.40939    59529.002    59529.002   -747.77264   -747.77264 
Loop time of 433.592 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.442 hours/ns, 2.306 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    | 432.51     | 432.51     | 432.51     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21055    | 0.21055    | 0.21055    |   0.0 |  0.05
Output  | 0.00018165 | 0.00018165 | 0.00018165 |   0.0 |  0.00
Modify  | 0.76416    | 0.76416    | 0.76416    |   0.0 |  0.18
Other   |            | 0.1043     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559630.0 ave      559630 max      559630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559630
Ave neighs/atom = 139.90750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.507907336398, Press = -1.33663811875274
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -15356.271   -15356.271   -15501.735   -15501.735    281.40939    281.40939    59529.002    59529.002   -747.77264   -747.77264 
   37000   -15363.794   -15363.794   -15504.563   -15504.563    272.32719    272.32719    59501.586    59501.586   -356.45106   -356.45106 
Loop time of 449.995 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.999 hours/ns, 2.222 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    | 448.87     | 448.87     | 448.87     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21624    | 0.21624    | 0.21624    |   0.0 |  0.05
Output  | 0.0002307  | 0.0002307  | 0.0002307  |   0.0 |  0.00
Modify  | 0.80542    | 0.80542    | 0.80542    |   0.0 |  0.18
Other   |            | 0.1078     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8192.00 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559600.0 ave      559600 max      559600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559600
Ave neighs/atom = 139.90000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.527456141915, Press = -0.925419193619979
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -15363.794   -15363.794   -15504.563   -15504.563    272.32719    272.32719    59501.586    59501.586   -356.45106   -356.45106 
   38000   -15361.462   -15361.462   -15502.157   -15502.157    272.18374    272.18374    59581.411    59581.411   -2598.3289   -2598.3289 
Loop time of 435.995 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.110 hours/ns, 2.294 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    | 434.9      | 434.9      | 434.9      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2131     | 0.2131     | 0.2131     |   0.0 |  0.05
Output  | 0.00017567 | 0.00017567 | 0.00017567 |   0.0 |  0.00
Modify  | 0.77394    | 0.77394    | 0.77394    |   0.0 |  0.18
Other   |            | 0.105      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8190.00 ave        8190 max        8190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559650.0 ave      559650 max      559650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559650
Ave neighs/atom = 139.91250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.506055040525, Press = 0.0977225414947798
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -15361.462   -15361.462   -15502.157   -15502.157    272.18374    272.18374    59581.411    59581.411   -2598.3289   -2598.3289 
   39000    -15363.03    -15363.03   -15503.309   -15503.309    271.38095    271.38095    59486.575    59486.575    194.79603    194.79603 
Loop time of 451.381 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.383 hours/ns, 2.215 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    | 450.25     | 450.25     | 450.25     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21625    | 0.21625    | 0.21625    |   0.0 |  0.05
Output  | 0.00023791 | 0.00023791 | 0.00023791 |   0.0 |  0.00
Modify  | 0.80759    | 0.80759    | 0.80759    |   0.0 |  0.18
Other   |            | 0.109      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559494.0 ave      559494 max      559494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559494
Ave neighs/atom = 139.87350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.51077692828, Press = -1.85706016394983
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -15363.03    -15363.03   -15503.309   -15503.309    271.38095    271.38095    59486.575    59486.575    194.79603    194.79603 
   40000   -15360.499   -15360.499   -15502.242   -15502.242    274.21249    274.21249    59479.215    59479.215      624.584      624.584 
Loop time of 428.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.909 hours/ns, 2.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 427        | 427        | 427        |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20821    | 0.20821    | 0.20821    |   0.0 |  0.05
Output  | 0.00017694 | 0.00017694 | 0.00017694 |   0.0 |  0.00
Modify  | 0.75881    | 0.75881    | 0.75881    |   0.0 |  0.18
Other   |            | 0.1062     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8187.00 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559590.0 ave      559590 max      559590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559590
Ave neighs/atom = 139.89750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.501791094004, Press = -0.899792782728392
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -15360.499   -15360.499   -15502.242   -15502.242    274.21249    274.21249    59479.215    59479.215      624.584      624.584 
   41000   -15362.654   -15362.654   -15504.679   -15504.679     274.7562     274.7562    59544.886    59544.886   -1738.0376   -1738.0376 
Loop time of 391.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.735 hours/ns, 2.555 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.48     | 390.48     | 390.48     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19524    | 0.19524    | 0.19524    |   0.0 |  0.05
Output  | 0.00018139 | 0.00018139 | 0.00018139 |   0.0 |  0.00
Modify  | 0.67061    | 0.67061    | 0.67061    |   0.0 |  0.17
Other   |            | 0.0975     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8182.00 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559572.0 ave      559572 max      559572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559572
Ave neighs/atom = 139.89300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.505624620262, Press = -0.836436722459369
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -15362.654   -15362.654   -15504.679   -15504.679     274.7562     274.7562    59544.886    59544.886   -1738.0376   -1738.0376 
   42000   -15359.865   -15359.865   -15502.528   -15502.528    275.98997    275.98997    59498.296    59498.296    29.995765    29.995765 
Loop time of 395.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.824 hours/ns, 2.529 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 394.39     | 394.39     | 394.39     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19739    | 0.19739    | 0.19739    |   0.0 |  0.05
Output  | 0.00017807 | 0.00017807 | 0.00017807 |   0.0 |  0.00
Modify  | 0.68151    | 0.68151    | 0.68151    |   0.0 |  0.17
Other   |            | 0.09875    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559518.0 ave      559518 max      559518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559518
Ave neighs/atom = 139.87950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.536640266621, Press = -1.26938250405913
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -15359.865   -15359.865   -15502.528   -15502.528    275.98997    275.98997    59498.296    59498.296    29.995765    29.995765 
   43000   -15361.831   -15361.831   -15503.781   -15503.781    274.61284    274.61284    59546.077    59546.077   -1617.5255   -1617.5255 
Loop time of 453.759 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.044 hours/ns, 2.204 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    | 452.62     | 452.62     | 452.62     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21633    | 0.21633    | 0.21633    |   0.0 |  0.05
Output  | 0.00022758 | 0.00022758 | 0.00022758 |   0.0 |  0.00
Modify  | 0.81716    | 0.81716    | 0.81716    |   0.0 |  0.18
Other   |            | 0.1097     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559616.0 ave      559616 max      559616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559616
Ave neighs/atom = 139.90400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.528709932735, Press = -0.379303177141398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -15361.831   -15361.831   -15503.781   -15503.781    274.61284    274.61284    59546.077    59546.077   -1617.5255   -1617.5255 
   44000   -15368.711   -15368.711   -15508.476   -15508.476    270.38477    270.38477    59430.342    59430.342    1355.6603    1355.6603 
Loop time of 461.888 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.302 hours/ns, 2.165 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    | 460.72     | 460.72     | 460.72     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21776    | 0.21776    | 0.21776    |   0.0 |  0.05
Output  | 0.00027643 | 0.00027643 | 0.00027643 |   0.0 |  0.00
Modify  | 0.83717    | 0.83717    | 0.83717    |   0.0 |  0.18
Other   |            | 0.1122     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559566.0 ave      559566 max      559566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559566
Ave neighs/atom = 139.89150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.517733026909, Press = -1.77790538522306
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -15368.711   -15368.711   -15508.476   -15508.476    270.38477    270.38477    59430.342    59430.342    1355.6603    1355.6603 
   45000   -15361.828   -15361.828   -15504.452   -15504.452     275.9164     275.9164    59519.212    59519.212   -949.20262   -949.20262 
Loop time of 393.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.185 hours/ns, 2.544 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.1      | 392.1      | 392.1      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19338    | 0.19338    | 0.19338    |   0.0 |  0.05
Output  | 0.00017994 | 0.00017994 | 0.00017994 |   0.0 |  0.00
Modify  | 0.677      | 0.677      | 0.677      |   0.0 |  0.17
Other   |            | 0.09878    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8192.00 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559714.0 ave      559714 max      559714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559714
Ave neighs/atom = 139.92850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.474923557056, Press = -0.531944547198993
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -15361.828   -15361.828   -15504.452   -15504.452     275.9164     275.9164    59519.212    59519.212   -949.20262   -949.20262 
   46000   -15361.434   -15361.434   -15503.039   -15503.039    273.94418    273.94418    59460.076    59460.076    1188.5646    1188.5646 
Loop time of 416.308 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.641 hours/ns, 2.402 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    | 415.27     | 415.27     | 415.27     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2045     | 0.2045     | 0.2045     |   0.0 |  0.05
Output  | 0.0001882  | 0.0001882  | 0.0001882  |   0.0 |  0.00
Modify  | 0.72988    | 0.72988    | 0.72988    |   0.0 |  0.18
Other   |            | 0.1031     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559616.0 ave      559616 max      559616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559616
Ave neighs/atom = 139.90400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.473813350716, Press = -1.82353538278151
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -15361.434   -15361.434   -15503.039   -15503.039    273.94418    273.94418    59460.076    59460.076    1188.5646    1188.5646 
   47000   -15361.241   -15361.241   -15502.273   -15502.273    272.83534    272.83534    59489.234    59489.234    310.03107    310.03107 
Loop time of 427.543 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.762 hours/ns, 2.339 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    | 426.47     | 426.47     | 426.47     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21024    | 0.21024    | 0.21024    |   0.0 |  0.05
Output  | 0.00018002 | 0.00018002 | 0.00018002 |   0.0 |  0.00
Modify  | 0.7567     | 0.7567     | 0.7567     |   0.0 |  0.18
Other   |            | 0.1056     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559716.0 ave      559716 max      559716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559716
Ave neighs/atom = 139.92900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.502169209323, Press = 0.187172842584364
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -15361.241   -15361.241   -15502.273   -15502.273    272.83534    272.83534    59489.234    59489.234    310.03107    310.03107 
   48000   -15361.183   -15361.183   -15503.162   -15503.162    274.66807    274.66807    59518.088    59518.088   -670.19395   -670.19395 
Loop time of 444.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 123.360 hours/ns, 2.252 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    | 442.98     | 442.98     | 442.98     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21232    | 0.21232    | 0.21232    |   0.0 |  0.05
Output  | 0.00018028 | 0.00018028 | 0.00018028 |   0.0 |  0.00
Modify  | 0.79567    | 0.79567    | 0.79567    |   0.0 |  0.18
Other   |            | 0.1091     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559656.0 ave      559656 max      559656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559656
Ave neighs/atom = 139.91400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.486374519901, Press = -1.37115884427228
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -15361.183   -15361.183   -15503.162   -15503.162    274.66807    274.66807    59518.088    59518.088   -670.19395   -670.19395 
   49000   -15367.814   -15367.814   -15505.642   -15505.642    266.63725    266.63725    59457.738    59457.738    918.85053    918.85053 
Loop time of 390.677 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.521 hours/ns, 2.560 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.71     | 389.71     | 389.71     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19473    | 0.19473    | 0.19473    |   0.0 |  0.05
Output  | 0.0001788  | 0.0001788  | 0.0001788  |   0.0 |  0.00
Modify  | 0.67315    | 0.67315    | 0.67315    |   0.0 |  0.17
Other   |            | 0.1022     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8190.00 ave        8190 max        8190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559534.0 ave      559534 max      559534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559534
Ave neighs/atom = 139.88350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.449954457483, Press = -0.261372625831744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -15367.814   -15367.814   -15505.642   -15505.642    266.63725    266.63725    59457.738    59457.738    918.85053    918.85053 
   50000   -15362.056   -15362.056   -15504.171   -15504.171    274.93213    274.93213    59525.655    59525.655   -1168.9886   -1168.9886 
Loop time of 389.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.281 hours/ns, 2.565 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.84     | 388.84     | 388.84     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1949     | 0.1949     | 0.1949     |   0.0 |  0.05
Output  | 0.00017687 | 0.00017687 | 0.00017687 |   0.0 |  0.00
Modify  | 0.67416    | 0.67416    | 0.67416    |   0.0 |  0.17
Other   |            | 0.1008     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8194.00 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559702.0 ave      559702 max      559702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559702
Ave neighs/atom = 139.92550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.439569011805, Press = -0.689343085452612
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -15362.056   -15362.056   -15504.171   -15504.171    274.93213    274.93213    59525.655    59525.655   -1168.9886   -1168.9886 
   51000   -15363.794   -15363.794    -15505.05    -15505.05    273.26846    273.26846    59493.505    59493.505   -141.01907   -141.01907 
Loop time of 389.988 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.330 hours/ns, 2.564 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.02     | 389.02     | 389.02     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19285    | 0.19285    | 0.19285    |   0.0 |  0.05
Output  | 0.00017961 | 0.00017961 | 0.00017961 |   0.0 |  0.00
Modify  | 0.67442    | 0.67442    | 0.67442    |   0.0 |  0.17
Other   |            | 0.1016     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8188.00 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559608.0 ave      559608 max      559608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559608
Ave neighs/atom = 139.90200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.445306079494, Press = -0.673131001116556
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -15363.794   -15363.794    -15505.05    -15505.05    273.26846    273.26846    59493.505    59493.505   -141.01907   -141.01907 
   52000   -15365.233   -15365.233   -15506.107   -15506.107    272.53058    272.53058    59498.605    59498.605   -540.68751   -540.68751 
Loop time of 390.047 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.346 hours/ns, 2.564 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.08     | 389.08     | 389.08     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19345    | 0.19345    | 0.19345    |   0.0 |  0.05
Output  | 0.00017888 | 0.00017888 | 0.00017888 |   0.0 |  0.00
Modify  | 0.67481    | 0.67481    | 0.67481    |   0.0 |  0.17
Other   |            | 0.1015     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559638.0 ave      559638 max      559638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559638
Ave neighs/atom = 139.90950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.448950613298, Press = -1.01776908937866
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -15365.233   -15365.233   -15506.107   -15506.107    272.53058    272.53058    59498.605    59498.605   -540.68751   -540.68751 
   53000    -15361.82    -15361.82   -15502.699   -15502.699    272.53959    272.53959    59484.411    59484.411    401.15134    401.15134 
Loop time of 389.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.216 hours/ns, 2.567 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.61     | 388.61     | 388.61     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19336    | 0.19336    | 0.19336    |   0.0 |  0.05
Output  | 0.0001791  | 0.0001791  | 0.0001791  |   0.0 |  0.00
Modify  | 0.67365    | 0.67365    | 0.67365    |   0.0 |  0.17
Other   |            | 0.1022     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8192.00 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559600.0 ave      559600 max      559600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559600
Ave neighs/atom = 139.90000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.397089259563, Press = -1.30368523249874
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000    -15361.82    -15361.82   -15502.699   -15502.699    272.53959    272.53959    59484.411    59484.411    401.15134    401.15134 
   54000   -15359.842   -15359.842   -15502.669   -15502.669    276.30921    276.30921    59486.739    59486.739    305.25876    305.25876 
Loop time of 389.793 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.276 hours/ns, 2.565 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.82     | 388.82     | 388.82     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19267    | 0.19267    | 0.19267    |   0.0 |  0.05
Output  | 0.00017932 | 0.00017932 | 0.00017932 |   0.0 |  0.00
Modify  | 0.67548    | 0.67548    | 0.67548    |   0.0 |  0.17
Other   |            | 0.1018     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559614.0 ave      559614 max      559614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559614
Ave neighs/atom = 139.90350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.39207349564, Press = 0.354774801681455
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -15359.842   -15359.842   -15502.669   -15502.669    276.30921    276.30921    59486.739    59486.739    305.25876    305.25876 
   55000   -15364.435   -15364.435   -15504.277   -15504.277    270.53463    270.53463    59504.421    59504.421   -375.82034   -375.82034 
Loop time of 389.914 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.309 hours/ns, 2.565 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.94     | 388.94     | 388.94     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19457    | 0.19457    | 0.19457    |   0.0 |  0.05
Output  | 0.00017886 | 0.00017886 | 0.00017886 |   0.0 |  0.00
Modify  | 0.67357    | 0.67357    | 0.67357    |   0.0 |  0.17
Other   |            | 0.1017     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559600.0 ave      559600 max      559600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559600
Ave neighs/atom = 139.90000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.399917090493, Press = -0.81933784538347
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -15364.435   -15364.435   -15504.277   -15504.277    270.53463    270.53463    59504.421    59504.421   -375.82034   -375.82034 
   56000   -15361.115   -15361.115   -15505.114   -15505.114    278.57682    278.57682    59484.265    59484.265    153.69823    153.69823 
Loop time of 390.468 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.463 hours/ns, 2.561 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.5      | 389.5      | 389.5      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19258    | 0.19258    | 0.19258    |   0.0 |  0.05
Output  | 0.00017942 | 0.00017942 | 0.00017942 |   0.0 |  0.00
Modify  | 0.67415    | 0.67415    | 0.67415    |   0.0 |  0.17
Other   |            | 0.102      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559632.0 ave      559632 max      559632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559632
Ave neighs/atom = 139.90800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.391587726395, Press = -1.2957109547658
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -15361.115   -15361.115   -15505.114   -15505.114    278.57682    278.57682    59484.265    59484.265    153.69823    153.69823 
   57000   -15365.055   -15365.055   -15505.553   -15505.553    271.80295    271.80295    59482.442    59482.442    74.168974    74.168974 
Loop time of 388.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.000 hours/ns, 2.572 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.84     | 387.84     | 387.84     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19095    | 0.19095    | 0.19095    |   0.0 |  0.05
Output  | 0.000178   | 0.000178   | 0.000178   |   0.0 |  0.00
Modify  | 0.66937    | 0.66937    | 0.66937    |   0.0 |  0.17
Other   |            | 0.1019     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559702.0 ave      559702 max      559702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559702
Ave neighs/atom = 139.92550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.354169520022, Press = -0.00979502087503972
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -15365.055   -15365.055   -15505.553   -15505.553    271.80295    271.80295    59482.442    59482.442    74.168974    74.168974 
   58000   -15363.645   -15363.645   -15501.962   -15501.962    267.58339    267.58339    59577.188    59577.188   -2541.1166   -2541.1166 
Loop time of 388.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.007 hours/ns, 2.572 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.86     | 387.86     | 387.86     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19169    | 0.19169    | 0.19169    |   0.0 |  0.05
Output  | 0.00017764 | 0.00017764 | 0.00017764 |   0.0 |  0.00
Modify  | 0.66997    | 0.66997    | 0.66997    |   0.0 |  0.17
Other   |            | 0.1012     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8188.00 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559740.0 ave      559740 max      559740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559740
Ave neighs/atom = 139.93500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.360714414768, Press = -1.23174190354292
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -15363.645   -15363.645   -15501.962   -15501.962    267.58339    267.58339    59577.188    59577.188   -2541.1166   -2541.1166 
   59000   -15363.124   -15363.124   -15503.918   -15503.918    272.37427    272.37427    59427.514    59427.514      2020.08      2020.08 
Loop time of 389.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.181 hours/ns, 2.568 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.49     | 388.49     | 388.49     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19219    | 0.19219    | 0.19219    |   0.0 |  0.05
Output  | 0.00018103 | 0.00018103 | 0.00018103 |   0.0 |  0.00
Modify  | 0.66979    | 0.66979    | 0.66979    |   0.0 |  0.17
Other   |            | 0.1018     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559554.0 ave      559554 max      559554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559554
Ave neighs/atom = 139.88850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.373910382563, Press = -0.500260109809845
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -15363.124   -15363.124   -15503.918   -15503.918    272.37427    272.37427    59427.514    59427.514      2020.08      2020.08 
   60000   -15359.472   -15359.472   -15504.414   -15504.414    280.39924    280.39924    59518.676    59518.676   -840.84913   -840.84913 
Loop time of 388.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.023 hours/ns, 2.571 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.92     | 387.92     | 387.92     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19298    | 0.19298    | 0.19298    |   0.0 |  0.05
Output  | 0.00017632 | 0.00017632 | 0.00017632 |   0.0 |  0.00
Modify  | 0.6687     | 0.6687     | 0.6687     |   0.0 |  0.17
Other   |            | 0.1016     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559710.0 ave      559710 max      559710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559710
Ave neighs/atom = 139.92750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.393266868709, Press = -0.186177856917191
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -15359.472   -15359.472   -15504.414   -15504.414    280.39924    280.39924    59518.676    59518.676   -840.84913   -840.84913 
   61000   -15360.072   -15360.072   -15503.811   -15503.811    278.07297    278.07297    59503.718    59503.718   -278.89552   -278.89552 
Loop time of 388.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.975 hours/ns, 2.573 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.75     | 387.75     | 387.75     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19138    | 0.19138    | 0.19138    |   0.0 |  0.05
Output  | 0.0001782  | 0.0001782  | 0.0001782  |   0.0 |  0.00
Modify  | 0.66898    | 0.66898    | 0.66898    |   0.0 |  0.17
Other   |            | 0.1016     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559624.0 ave      559624 max      559624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559624
Ave neighs/atom = 139.90600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.390384949948, Press = -0.997632300748532
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -15360.072   -15360.072   -15503.811   -15503.811    278.07297    278.07297    59503.718    59503.718   -278.89552   -278.89552 
   62000   -15365.589   -15365.589   -15505.093   -15505.093    269.88059    269.88059    59478.888    59478.888    272.78501    272.78501 
Loop time of 388.815 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.004 hours/ns, 2.572 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.85     | 387.85     | 387.85     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19242    | 0.19242    | 0.19242    |   0.0 |  0.05
Output  | 0.00018009 | 0.00018009 | 0.00018009 |   0.0 |  0.00
Modify  | 0.67044    | 0.67044    | 0.67044    |   0.0 |  0.17
Other   |            | 0.1004     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8182.00 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559668.0 ave      559668 max      559668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559668
Ave neighs/atom = 139.91700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.360213416885, Press = 0.0659881241712932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -15365.589   -15365.589   -15505.093   -15505.093    269.88059    269.88059    59478.888    59478.888    272.78501    272.78501 
   63000   -15360.065   -15360.065   -15501.592   -15501.592    273.79524    273.79524    59526.626    59526.626   -788.17361   -788.17361 
Loop time of 388.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.877 hours/ns, 2.575 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.39     | 387.39     | 387.39     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19132    | 0.19132    | 0.19132    |   0.0 |  0.05
Output  | 0.00017807 | 0.00017807 | 0.00017807 |   0.0 |  0.00
Modify  | 0.67089    | 0.67089    | 0.67089    |   0.0 |  0.17
Other   |            | 0.1004     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559624.0 ave      559624 max      559624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559624
Ave neighs/atom = 139.90600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.332659677108, Press = -1.32932815411699
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -15360.065   -15360.065   -15501.592   -15501.592    273.79524    273.79524    59526.626    59526.626   -788.17361   -788.17361 
   64000   -15358.745   -15358.745   -15500.537   -15500.537    274.30613    274.30613     59445.75     59445.75    1873.8677    1873.8677 
Loop time of 389.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.059 hours/ns, 2.571 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.05     | 388.05     | 388.05     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19193    | 0.19193    | 0.19193    |   0.0 |  0.05
Output  | 0.00017727 | 0.00017727 | 0.00017727 |   0.0 |  0.00
Modify  | 0.66917    | 0.66917    | 0.66917    |   0.0 |  0.17
Other   |            | 0.1018     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559620.0 ave      559620 max      559620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0