# 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 5.430545687675476*${_u_distance}
variable latticeconst_converted equal 5.430545687675476*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.43054568767548
Lattice spacing in x,y,z = 5.4305457 5.4305457 5.4305457
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 (54.305457 54.305457 54.305457)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (54.305457 54.305457 54.305457)
  create_atoms CPU = 0.006 seconds

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

kim_interactions Si

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

kim interactions Si
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LenoskySadighAlonso_2000_Si__MO_533426548156_001
pair_coeff * * Si
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 28.0855

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 160151.280490546 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_533426548156_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.677 | 4.677 | 4.677 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -36551.257   -36551.257    -36854.36    -36854.36       293.15       293.15    160151.28    160151.28    2021.5147    2021.5147 
    1000   -36206.829   -36206.829   -36510.093   -36510.093    293.30623    293.30623    158532.94    158532.94     745.5234     745.5234 
Loop time of 141.576 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.610 ns/day, 39.327 hours/ns, 7.063 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.86     | 140.86     | 140.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05983    | 0.05983    | 0.05983    |   0.0 |  0.04
Output  | 0.00030309 | 0.00030309 | 0.00030309 |   0.0 |  0.00
Modify  | 0.58713    | 0.58713    | 0.58713    |   0.0 |  0.41
Other   |            | 0.06882    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      368000.0 ave      368000 max      368000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 368000
Ave neighs/atom = 46.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -36206.829   -36206.829   -36510.093   -36510.093    293.30623    293.30623    158532.94    158532.94     745.5234     745.5234 
    2000   -36241.624   -36241.624   -36545.098   -36545.098    293.50871    293.50871    158867.34    158867.34    -105.0705    -105.0705 
Loop time of 143.655 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.601 ns/day, 39.904 hours/ns, 6.961 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.94     | 142.94     | 142.94     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059565   | 0.059565   | 0.059565   |   0.0 |  0.04
Output  | 0.00015838 | 0.00015838 | 0.00015838 |   0.0 |  0.00
Modify  | 0.58431    | 0.58431    | 0.58431    |   0.0 |  0.41
Other   |            | 0.06816    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386876.0 ave      386876 max      386876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386876
Ave neighs/atom = 48.359500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -36241.624   -36241.624   -36545.098   -36545.098    293.50871    293.50871    158867.34    158867.34    -105.0705    -105.0705 
    3000   -36217.122   -36217.122    -36522.45    -36522.45    295.30188    295.30188    158824.38    158824.38   -887.33786   -887.33786 
Loop time of 143.171 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.603 ns/day, 39.770 hours/ns, 6.985 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.46     | 142.46     | 142.46     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059476   | 0.059476   | 0.059476   |   0.0 |  0.04
Output  | 0.00015097 | 0.00015097 | 0.00015097 |   0.0 |  0.00
Modify  | 0.58473    | 0.58473    | 0.58473    |   0.0 |  0.41
Other   |            | 0.06819    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      383526.0 ave      383526 max      383526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 383526
Ave neighs/atom = 47.940750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -36217.122   -36217.122    -36522.45    -36522.45    295.30188    295.30188    158824.38    158824.38   -887.33786   -887.33786 
    4000   -36237.314   -36237.314   -36534.518   -36534.518    287.44459    287.44459    158635.12    158635.12    472.89582    472.89582 
Loop time of 143.223 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.603 ns/day, 39.784 hours/ns, 6.982 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.51     | 142.51     | 142.51     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059502   | 0.059502   | 0.059502   |   0.0 |  0.04
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.58363    | 0.58363    | 0.58363    |   0.0 |  0.41
Other   |            | 0.06776    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385968.0 ave      385968 max      385968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385968
Ave neighs/atom = 48.246000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -36237.314   -36237.314   -36534.518   -36534.518    287.44459    287.44459    158635.12    158635.12    472.89582    472.89582 
    5000   -36220.582   -36220.582   -36527.048   -36527.048    296.40219    296.40219    158783.45    158783.45   -237.04688   -237.04688 
Loop time of 143.135 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.604 ns/day, 39.760 hours/ns, 6.986 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.42     | 142.42     | 142.42     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059329   | 0.059329   | 0.059329   |   0.0 |  0.04
Output  | 0.00012654 | 0.00012654 | 0.00012654 |   0.0 |  0.00
Modify  | 0.5831     | 0.5831     | 0.5831     |   0.0 |  0.41
Other   |            | 0.06781    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6729.00 ave        6729 max        6729 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385226.0 ave      385226 max      385226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385226
Ave neighs/atom = 48.153250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 297.52058225987, Press = -13.0065913370084
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -36220.582   -36220.582   -36527.048   -36527.048    296.40219    296.40219    158783.45    158783.45   -237.04688   -237.04688 
    6000   -36233.943   -36233.943   -36536.481   -36536.481    292.60395    292.60395    158742.37    158742.37   -13.116668   -13.116668 
Loop time of 182.76 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.473 ns/day, 50.767 hours/ns, 5.472 timesteps/s
98.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    | 181.75     | 181.75     | 181.75     |   0.0 | 99.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080458   | 0.080458   | 0.080458   |   0.0 |  0.04
Output  | 0.00012513 | 0.00012513 | 0.00012513 |   0.0 |  0.00
Modify  | 0.81959    | 0.81959    | 0.81959    |   0.0 |  0.45
Other   |            | 0.1064     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385092.0 ave      385092 max      385092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385092
Ave neighs/atom = 48.136500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.176359620964, Press = -1.53079260786251
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -36233.943   -36233.943   -36536.481   -36536.481    292.60395    292.60395    158742.37    158742.37   -13.116668   -13.116668 
    7000   -36223.756   -36223.756   -36526.053   -36526.053    292.37016    292.37016    158553.38    158553.38       564.34       564.34 
Loop time of 191.594 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.451 ns/day, 53.220 hours/ns, 5.219 timesteps/s
95.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.59     | 190.59     | 190.59     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080713   | 0.080713   | 0.080713   |   0.0 |  0.04
Output  | 0.00012604 | 0.00012604 | 0.00012604 |   0.0 |  0.00
Modify  | 0.81796    | 0.81796    | 0.81796    |   0.0 |  0.43
Other   |            | 0.1068     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384994.0 ave      384994 max      384994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384994
Ave neighs/atom = 48.124250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.354162509425, Press = -4.52989977902486
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -36223.756   -36223.756   -36526.053   -36526.053    292.37016    292.37016    158553.38    158553.38       564.34       564.34 
    8000   -36230.867   -36230.867   -36532.491   -36532.491    291.71987    291.71987    158830.71    158830.71   -904.97869   -904.97869 
Loop time of 151.745 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.569 ns/day, 42.151 hours/ns, 6.590 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.94     | 150.94     | 150.94     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064901   | 0.064901   | 0.064901   |   0.0 |  0.04
Output  | 0.00014355 | 0.00014355 | 0.00014355 |   0.0 |  0.00
Modify  | 0.65354    | 0.65354    | 0.65354    |   0.0 |  0.43
Other   |            | 0.08791    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386604.0 ave      386604 max      386604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386604
Ave neighs/atom = 48.325500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.166560253598, Press = -2.50033822800301
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -36230.867   -36230.867   -36532.491   -36532.491    291.71987    291.71987    158830.71    158830.71   -904.97869   -904.97869 
    9000   -36226.269   -36226.269   -36529.643   -36529.643    293.41198    293.41198    158734.23    158734.23   -325.68781   -325.68781 
Loop time of 152.408 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.567 ns/day, 42.336 hours/ns, 6.561 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    | 151.59     | 151.59     | 151.59     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065716   | 0.065716   | 0.065716   |   0.0 |  0.04
Output  | 0.00013199 | 0.00013199 | 0.00013199 |   0.0 |  0.00
Modify  | 0.66256    | 0.66256    | 0.66256    |   0.0 |  0.43
Other   |            | 0.08991    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385290.0 ave      385290 max      385290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385290
Ave neighs/atom = 48.161250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.282894840153, Press = -4.94416551451987
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -36226.269   -36226.269   -36529.643   -36529.643    293.41198    293.41198    158734.23    158734.23   -325.68781   -325.68781 
   10000   -36229.112   -36229.112   -36531.183   -36531.183    292.15181    292.15181    158627.39    158627.39    202.92379    202.92379 
Loop time of 169.532 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.510 ns/day, 47.092 hours/ns, 5.899 timesteps/s
96.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.62     | 168.62     | 168.62     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08372    | 0.08372    | 0.08372    |   0.0 |  0.05
Output  | 0.00013515 | 0.00013515 | 0.00013515 |   0.0 |  0.00
Modify  | 0.73837    | 0.73837    | 0.73837    |   0.0 |  0.44
Other   |            | 0.09433    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385834.0 ave      385834 max      385834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385834
Ave neighs/atom = 48.229250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.158015155527, Press = -1.81140440527753
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -36229.112   -36229.112   -36531.183   -36531.183    292.15181    292.15181    158627.39    158627.39    202.92379    202.92379 
   11000   -36227.173   -36227.173   -36529.172   -36529.172    292.08234    292.08234    158666.17    158666.17   -32.984662   -32.984662 
Loop time of 175.388 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.493 ns/day, 48.719 hours/ns, 5.702 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    | 174.44     | 174.44     | 174.44     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07486    | 0.07486    | 0.07486    |   0.0 |  0.04
Output  | 0.00013104 | 0.00013104 | 0.00013104 |   0.0 |  0.00
Modify  | 0.7711     | 0.7711     | 0.7711     |   0.0 |  0.44
Other   |            | 0.09854    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386050.0 ave      386050 max      386050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386050
Ave neighs/atom = 48.256250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.264285992526, Press = 0.853835636737374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -36227.173   -36227.173   -36529.172   -36529.172    292.08234    292.08234    158666.17    158666.17   -32.984662   -32.984662 
   12000   -36230.694   -36230.694   -36537.773   -36537.773    296.99457    296.99457    158774.75    158774.75   -353.09101   -353.09101 
Loop time of 163.345 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.529 ns/day, 45.374 hours/ns, 6.122 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    | 162.47     | 162.47     | 162.47     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0708     | 0.0708     | 0.0708     |   0.0 |  0.04
Output  | 0.0001343  | 0.0001343  | 0.0001343  |   0.0 |  0.00
Modify  | 0.71119    | 0.71119    | 0.71119    |   0.0 |  0.44
Other   |            | 0.09404    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386112.0 ave      386112 max      386112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386112
Ave neighs/atom = 48.264000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.225104478376, Press = 1.65979977196995
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -36230.694   -36230.694   -36537.773   -36537.773    296.99457    296.99457    158774.75    158774.75   -353.09101   -353.09101 
   13000   -36223.857   -36223.857   -36526.867   -36526.867    293.05976    293.05976    158749.58    158749.58   -395.41922   -395.41922 
Loop time of 152.73 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.566 ns/day, 42.425 hours/ns, 6.548 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.91     | 151.91     | 151.91     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065905   | 0.065905   | 0.065905   |   0.0 |  0.04
Output  | 0.00012797 | 0.00012797 | 0.00012797 |   0.0 |  0.00
Modify  | 0.66434    | 0.66434    | 0.66434    |   0.0 |  0.43
Other   |            | 0.08936    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384984.0 ave      384984 max      384984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384984
Ave neighs/atom = 48.123000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.228879704274, Press = -0.233754574452856
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -36223.857   -36223.857   -36526.867   -36526.867    293.05976    293.05976    158749.58    158749.58   -395.41922   -395.41922 
   14000   -36239.542   -36239.542   -36537.599   -36537.599    288.27012    288.27012    158720.78    158720.78   -105.98902   -105.98902 
Loop time of 162.497 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.532 ns/day, 45.138 hours/ns, 6.154 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    | 161.62     | 161.62     | 161.62     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068847   | 0.068847   | 0.068847   |   0.0 |  0.04
Output  | 0.00014408 | 0.00014408 | 0.00014408 |   0.0 |  0.00
Modify  | 0.71495    | 0.71495    | 0.71495    |   0.0 |  0.44
Other   |            | 0.09112    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386032.0 ave      386032 max      386032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386032
Ave neighs/atom = 48.254000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.103244819083, Press = -2.42295008399931
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -36239.542   -36239.542   -36537.599   -36537.599    288.27012    288.27012    158720.78    158720.78   -105.98902   -105.98902 
   15000   -36226.683   -36226.683   -36532.891   -36532.891    296.15253    296.15253    158666.02    158666.02    111.06455    111.06455 
Loop time of 159.228 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.543 ns/day, 44.230 hours/ns, 6.280 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    | 158.37     | 158.37     | 158.37     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067859   | 0.067859   | 0.067859   |   0.0 |  0.04
Output  | 0.00015061 | 0.00015061 | 0.00015061 |   0.0 |  0.00
Modify  | 0.69671    | 0.69671    | 0.69671    |   0.0 |  0.44
Other   |            | 0.09077    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385326.0 ave      385326 max      385326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385326
Ave neighs/atom = 48.165750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.02781404771, Press = -1.52198418748662
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -36226.683   -36226.683   -36532.891   -36532.891    296.15253    296.15253    158666.02    158666.02    111.06455    111.06455 
   16000   -36235.988   -36235.988   -36531.876   -36531.876    286.17163    286.17163    158611.66    158611.66    276.20504    276.20504 
Loop time of 155.026 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.557 ns/day, 43.063 hours/ns, 6.451 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.19     | 154.19     | 154.19     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067145   | 0.067145   | 0.067145   |   0.0 |  0.04
Output  | 0.00012851 | 0.00012851 | 0.00012851 |   0.0 |  0.00
Modify  | 0.67487    | 0.67487    | 0.67487    |   0.0 |  0.44
Other   |            | 0.09081    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385772.0 ave      385772 max      385772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385772
Ave neighs/atom = 48.221500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.984762410602, Press = 0.642867965835584
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -36235.988   -36235.988   -36531.876   -36531.876    286.17163    286.17163    158611.66    158611.66    276.20504    276.20504 
   17000   -36228.188   -36228.188   -36532.681   -36532.681    294.49417    294.49417    158806.67    158806.67   -627.45871   -627.45871 
Loop time of 197.402 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.438 ns/day, 54.834 hours/ns, 5.066 timesteps/s
96.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    | 196.29     | 196.29     | 196.29     |   0.0 | 99.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082609   | 0.082609   | 0.082609   |   0.0 |  0.04
Output  | 0.00014716 | 0.00014716 | 0.00014716 |   0.0 |  0.00
Modify  | 0.91935    | 0.91935    | 0.91935    |   0.0 |  0.47
Other   |            | 0.1098     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386118.0 ave      386118 max      386118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386118
Ave neighs/atom = 48.264750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.870142444006, Press = 0.166610849274802
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -36228.188   -36228.188   -36532.681   -36532.681    294.49417    294.49417    158806.67    158806.67   -627.45871   -627.45871 
   18000   -36233.674   -36233.674   -36535.875   -36535.875    292.27791    292.27791    158715.03    158715.03   -24.025114   -24.025114 
Loop time of 181.599 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.476 ns/day, 50.444 hours/ns, 5.507 timesteps/s
98.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    | 180.62     | 180.62     | 180.62     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07684    | 0.07684    | 0.07684    |   0.0 |  0.04
Output  | 0.00013753 | 0.00013753 | 0.00013753 |   0.0 |  0.00
Modify  | 0.79696    | 0.79696    | 0.79696    |   0.0 |  0.44
Other   |            | 0.1008     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385410.0 ave      385410 max      385410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385410
Ave neighs/atom = 48.176250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.873937793556, Press = -0.153111564805827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -36233.674   -36233.674   -36535.875   -36535.875    292.27791    292.27791    158715.03    158715.03   -24.025114   -24.025114 
   19000   -36227.544   -36227.544   -36531.697   -36531.697    294.16503    294.16503    158629.19    158629.19    476.71549    476.71549 
Loop time of 165.012 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.524 ns/day, 45.837 hours/ns, 6.060 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 164.12     | 164.12     | 164.12     |   0.0 | 99.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06864    | 0.06864    | 0.06864    |   0.0 |  0.04
Output  | 0.00013289 | 0.00013289 | 0.00013289 |   0.0 |  0.00
Modify  | 0.72819    | 0.72819    | 0.72819    |   0.0 |  0.44
Other   |            | 0.09088    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385348.0 ave      385348 max      385348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385348
Ave neighs/atom = 48.168500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.869505668533, Press = -0.817260635095212
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -36227.544   -36227.544   -36531.697   -36531.697    294.16503    294.16503    158629.19    158629.19    476.71549    476.71549 
   20000   -36232.772   -36232.772   -36533.093   -36533.093     290.4597     290.4597    158730.55    158730.55    -101.0028    -101.0028 
Loop time of 204.857 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.422 ns/day, 56.905 hours/ns, 4.881 timesteps/s
82.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.71     | 203.71     | 203.71     |   0.0 | 99.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07292    | 0.07292    | 0.07292    |   0.0 |  0.04
Output  | 0.00026504 | 0.00026504 | 0.00026504 |   0.0 |  0.00
Modify  | 0.94709    | 0.94709    | 0.94709    |   0.0 |  0.46
Other   |            | 0.1234     |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385750.0 ave      385750 max      385750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385750
Ave neighs/atom = 48.218750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.805582799129, Press = 1.20137022964159
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -36232.772   -36232.772   -36533.093   -36533.093     290.4597     290.4597    158730.55    158730.55    -101.0028    -101.0028 
   21000   -36223.658   -36223.658   -36530.138   -36530.138    296.41607    296.41607    158681.54    158681.54   -5.3345942   -5.3345942 
Loop time of 146.678 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.589 ns/day, 40.744 hours/ns, 6.818 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    | 145.92     | 145.92     | 145.92     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061379   | 0.061379   | 0.061379   |   0.0 |  0.04
Output  | 0.00013335 | 0.00013335 | 0.00013335 |   0.0 |  0.00
Modify  | 0.62049    | 0.62049    | 0.62049    |   0.0 |  0.42
Other   |            | 0.0735     |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385158.0 ave      385158 max      385158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385158
Ave neighs/atom = 48.144750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.791324083749, Press = -0.399326985434438
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -36223.658   -36223.658   -36530.138   -36530.138    296.41607    296.41607    158681.54    158681.54   -5.3345942   -5.3345942 
   22000   -36227.865   -36227.865   -36532.787   -36532.787    294.90918    294.90918     158641.4     158641.4    200.66375    200.66375 
Loop time of 142.757 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.605 ns/day, 39.655 hours/ns, 7.005 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.04     | 142.04     | 142.04     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059932   | 0.059932   | 0.059932   |   0.0 |  0.04
Output  | 0.00012191 | 0.00012191 | 0.00012191 |   0.0 |  0.00
Modify  | 0.5938     | 0.5938     | 0.5938     |   0.0 |  0.42
Other   |            | 0.06811    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6730.00 ave        6730 max        6730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385906.0 ave      385906 max      385906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385906
Ave neighs/atom = 48.238250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.815148992724, Press = -0.940939323605123
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -36227.865   -36227.865   -36532.787   -36532.787    294.90918    294.90918     158641.4     158641.4    200.66375    200.66375 
   23000    -36235.54    -36235.54   -36535.595   -36535.595    290.20154    290.20154    158557.67    158557.67    648.08247    648.08247 
Loop time of 142.798 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.605 ns/day, 39.666 hours/ns, 7.003 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.08     | 142.08     | 142.08     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059383   | 0.059383   | 0.059383   |   0.0 |  0.04
Output  | 0.00012725 | 0.00012725 | 0.00012725 |   0.0 |  0.00
Modify  | 0.59589    | 0.59589    | 0.59589    |   0.0 |  0.42
Other   |            | 0.06763    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386120.0 ave      386120 max      386120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386120
Ave neighs/atom = 48.265000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.75447596539, Press = -0.187101393149826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000    -36235.54    -36235.54   -36535.595   -36535.595    290.20154    290.20154    158557.67    158557.67    648.08247    648.08247 
   24000   -36225.556   -36225.556   -36531.507   -36531.507    295.90453    295.90453    158675.93    158675.93   -122.60722   -122.60722 
Loop time of 143.297 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.603 ns/day, 39.805 hours/ns, 6.979 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.57     | 142.57     | 142.57     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059285   | 0.059285   | 0.059285   |   0.0 |  0.04
Output  | 0.0001246  | 0.0001246  | 0.0001246  |   0.0 |  0.00
Modify  | 0.59574    | 0.59574    | 0.59574    |   0.0 |  0.42
Other   |            | 0.0679     |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385920.0 ave      385920 max      385920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385920
Ave neighs/atom = 48.240000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.762151754725, Press = 0.874595601759626
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -36225.556   -36225.556   -36531.507   -36531.507    295.90453    295.90453    158675.93    158675.93   -122.60722   -122.60722 
   25000   -36230.359   -36230.359    -36535.89    -36535.89    295.49901    295.49901    158794.04    158794.04   -557.51407   -557.51407 
Loop time of 143.04 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.604 ns/day, 39.733 hours/ns, 6.991 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.32     | 142.32     | 142.32     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059802   | 0.059802   | 0.059802   |   0.0 |  0.04
Output  | 0.00012735 | 0.00012735 | 0.00012735 |   0.0 |  0.00
Modify  | 0.59566    | 0.59566    | 0.59566    |   0.0 |  0.42
Other   |            | 0.06779    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386170.0 ave      386170 max      386170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386170
Ave neighs/atom = 48.271250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.793254576963, Press = -0.159647557316189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -36230.359   -36230.359    -36535.89    -36535.89    295.49901    295.49901    158794.04    158794.04   -557.51407   -557.51407 
   26000   -36225.945   -36225.945   -36529.035   -36529.035     293.1374     293.1374    158829.74    158829.74   -552.95423   -552.95423 
Loop time of 143.282 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.603 ns/day, 39.800 hours/ns, 6.979 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.56     | 142.56     | 142.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059965   | 0.059965   | 0.059965   |   0.0 |  0.04
Output  | 0.0001418  | 0.0001418  | 0.0001418  |   0.0 |  0.00
Modify  | 0.59743    | 0.59743    | 0.59743    |   0.0 |  0.42
Other   |            | 0.06814    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385282.0 ave      385282 max      385282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385282
Ave neighs/atom = 48.160250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837535956273, Press = -1.9670399607131
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -36225.945   -36225.945   -36529.035   -36529.035     293.1374     293.1374    158829.74    158829.74   -552.95423   -552.95423 
   27000    -36229.42    -36229.42   -36533.009   -36533.009    293.61945    293.61945    158471.12    158471.12    981.55773    981.55773 
Loop time of 143.406 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.602 ns/day, 39.835 hours/ns, 6.973 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.68     | 142.68     | 142.68     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059573   | 0.059573   | 0.059573   |   0.0 |  0.04
Output  | 0.00013065 | 0.00013065 | 0.00013065 |   0.0 |  0.00
Modify  | 0.59768    | 0.59768    | 0.59768    |   0.0 |  0.42
Other   |            | 0.0681     |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384694.0 ave      384694 max      384694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384694
Ave neighs/atom = 48.086750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.844982830346, Press = 0.295945679473275
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000    -36229.42    -36229.42   -36533.009   -36533.009    293.61945    293.61945    158471.12    158471.12    981.55773    981.55773 
   28000   -36224.397   -36224.397   -36525.834   -36525.834    291.53893    291.53893    158786.03    158786.03   -501.17365   -501.17365 
Loop time of 143.252 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.603 ns/day, 39.792 hours/ns, 6.981 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.53     | 142.53     | 142.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059693   | 0.059693   | 0.059693   |   0.0 |  0.04
Output  | 0.00013108 | 0.00013108 | 0.00013108 |   0.0 |  0.00
Modify  | 0.59706    | 0.59706    | 0.59706    |   0.0 |  0.42
Other   |            | 0.06851    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386826.0 ave      386826 max      386826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386826
Ave neighs/atom = 48.353250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.862313433913, Press = 0.252112703203469
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -36224.397   -36224.397   -36525.834   -36525.834    291.53893    291.53893    158786.03    158786.03   -501.17365   -501.17365 
   29000   -36227.028   -36227.028   -36536.346   -36536.346    299.16031    299.16031    158619.67    158619.67    434.18461    434.18461 
Loop time of 145.03 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.596 ns/day, 40.286 hours/ns, 6.895 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.29     | 144.29     | 144.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060846   | 0.060846   | 0.060846   |   0.0 |  0.04
Output  | 0.00013898 | 0.00013898 | 0.00013898 |   0.0 |  0.00
Modify  | 0.61075    | 0.61075    | 0.61075    |   0.0 |  0.42
Other   |            | 0.07182    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385658.0 ave      385658 max      385658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385658
Ave neighs/atom = 48.207250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818006528565, Press = -0.932336656268514
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -36227.028   -36227.028   -36536.346   -36536.346    299.16031    299.16031    158619.67    158619.67    434.18461    434.18461 
   30000   -36231.645   -36231.645   -36532.612   -36532.612    291.08436    291.08436    158600.11    158600.11    391.80657    391.80657 
Loop time of 143.017 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.604 ns/day, 39.727 hours/ns, 6.992 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.27     | 142.27     | 142.27     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061756   | 0.061756   | 0.061756   |   0.0 |  0.04
Output  | 0.00012505 | 0.00012505 | 0.00012505 |   0.0 |  0.00
Modify  | 0.6084     | 0.6084     | 0.6084     |   0.0 |  0.43
Other   |            | 0.08043    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385692.0 ave      385692 max      385692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385692
Ave neighs/atom = 48.211500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.83080107947, Press = -0.166602692016594
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -36231.645   -36231.645   -36532.612   -36532.612    291.08436    291.08436    158600.11    158600.11    391.80657    391.80657 
   31000   -36231.126   -36231.126   -36531.466   -36531.466    290.47728    290.47728    158636.14    158636.14    83.148154    83.148154 
Loop time of 144.74 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.597 ns/day, 40.206 hours/ns, 6.909 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.97     | 143.97     | 143.97     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062306   | 0.062306   | 0.062306   |   0.0 |  0.04
Output  | 0.00012716 | 0.00012716 | 0.00012716 |   0.0 |  0.00
Modify  | 0.62013    | 0.62013    | 0.62013    |   0.0 |  0.43
Other   |            | 0.08397    |            |       |  0.06

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386430.0 ave      386430 max      386430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386430
Ave neighs/atom = 48.303750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.872700491141, Press = 0.0104069107543068
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -36231.126   -36231.126   -36531.466   -36531.466    290.47728    290.47728    158636.14    158636.14    83.148154    83.148154 
   32000   -36225.739   -36225.739   -36528.447   -36528.447    292.76822    292.76822    158655.15    158655.15   -63.986992   -63.986992 
Loop time of 143.614 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.602 ns/day, 39.893 hours/ns, 6.963 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.89     | 142.89     | 142.89     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05979    | 0.05979    | 0.05979    |   0.0 |  0.04
Output  | 0.00012579 | 0.00012579 | 0.00012579 |   0.0 |  0.00
Modify  | 0.59979    | 0.59979    | 0.59979    |   0.0 |  0.42
Other   |            | 0.0682     |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386118.0 ave      386118 max      386118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386118
Ave neighs/atom = 48.264750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.88174909766, Press = -0.0594563441780763
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -36225.739   -36225.739   -36528.447   -36528.447    292.76822    292.76822    158655.15    158655.15   -63.986992   -63.986992 
   33000   -36232.655   -36232.655     -36530.5     -36530.5    288.06471    288.06471     158683.9     158683.9   -33.341545   -33.341545 
Loop time of 143.178 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.603 ns/day, 39.772 hours/ns, 6.984 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.45     | 142.45     | 142.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059523   | 0.059523   | 0.059523   |   0.0 |  0.04
Output  | 0.00013026 | 0.00013026 | 0.00013026 |   0.0 |  0.00
Modify  | 0.59694    | 0.59694    | 0.59694    |   0.0 |  0.42
Other   |            | 0.06805    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386406.0 ave      386406 max      386406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386406
Ave neighs/atom = 48.300750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.903509811197, Press = -0.041838761289444
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -36232.655   -36232.655     -36530.5     -36530.5    288.06471    288.06471     158683.9     158683.9   -33.341545   -33.341545 
   34000   -36226.212   -36226.212    -36529.92    -36529.92    293.73498    293.73498    158680.43    158680.43   -131.01047   -131.01047 
Loop time of 141.44 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.611 ns/day, 39.289 hours/ns, 7.070 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.73     | 140.73     | 140.73     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059586   | 0.059586   | 0.059586   |   0.0 |  0.04
Output  | 0.00012902 | 0.00012902 | 0.00012902 |   0.0 |  0.00
Modify  | 0.58599    | 0.58599    | 0.58599    |   0.0 |  0.41
Other   |            | 0.0664     |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386110.0 ave      386110 max      386110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386110
Ave neighs/atom = 48.263750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.903873208277, Press = 0.264224073195723
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -36226.212   -36226.212    -36529.92    -36529.92    293.73498    293.73498    158680.43    158680.43   -131.01047   -131.01047 
   35000   -36234.056   -36234.056   -36532.429   -36532.429    288.57556    288.57556    158777.77    158777.77    -137.2355    -137.2355 
Loop time of 136.646 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.957 hours/ns, 7.318 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.97     | 135.97     | 135.97     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057703   | 0.057703   | 0.057703   |   0.0 |  0.04
Output  | 0.00012381 | 0.00012381 | 0.00012381 |   0.0 |  0.00
Modify  | 0.55846    | 0.55846    | 0.55846    |   0.0 |  0.41
Other   |            | 0.06218    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6734.00 ave        6734 max        6734 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386122.0 ave      386122 max      386122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386122
Ave neighs/atom = 48.265250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.869720380641, Press = -0.185222226621418
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -36234.056   -36234.056   -36532.429   -36532.429    288.57556    288.57556    158777.77    158777.77    -137.2355    -137.2355 
   36000   -36227.379   -36227.379   -36532.987   -36532.987    295.57288    295.57288    158661.74    158661.74    192.46501    192.46501 
Loop time of 136.756 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.988 hours/ns, 7.312 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.08     | 136.08     | 136.08     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057667   | 0.057667   | 0.057667   |   0.0 |  0.04
Output  | 0.0001244  | 0.0001244  | 0.0001244  |   0.0 |  0.00
Modify  | 0.55851    | 0.55851    | 0.55851    |   0.0 |  0.41
Other   |            | 0.06242    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384714.0 ave      384714 max      384714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384714
Ave neighs/atom = 48.089250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.884583646643, Press = 0.247354990752484
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -36227.379   -36227.379   -36532.987   -36532.987    295.57288    295.57288    158661.74    158661.74    192.46501    192.46501 
   37000   -36224.745   -36224.745   -36524.142   -36524.142    289.56555    289.56555     158653.7     158653.7   -25.933105   -25.933105 
Loop time of 136.773 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.992 hours/ns, 7.311 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.09     | 136.09     | 136.09     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057296   | 0.057296   | 0.057296   |   0.0 |  0.04
Output  | 0.00012202 | 0.00012202 | 0.00012202 |   0.0 |  0.00
Modify  | 0.55832    | 0.55832    | 0.55832    |   0.0 |  0.41
Other   |            | 0.06216    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385408.0 ave      385408 max      385408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385408
Ave neighs/atom = 48.176000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.87025864787, Press = 0.258261619334998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -36224.745   -36224.745   -36524.142   -36524.142    289.56555    289.56555     158653.7     158653.7   -25.933105   -25.933105 
   38000    -36226.48    -36226.48    -36529.05    -36529.05    292.63448    292.63448    158684.62    158684.62    28.407305    28.407305 
Loop time of 136.67 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.964 hours/ns, 7.317 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136        | 136        | 136        |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056762   | 0.056762   | 0.056762   |   0.0 |  0.04
Output  | 0.00012639 | 0.00012639 | 0.00012639 |   0.0 |  0.00
Modify  | 0.55572    | 0.55572    | 0.55572    |   0.0 |  0.41
Other   |            | 0.06168    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386026.0 ave      386026 max      386026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386026
Ave neighs/atom = 48.253250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.85391709566, Press = -0.0813564435097349
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -36226.48    -36226.48    -36529.05    -36529.05    292.63448    292.63448    158684.62    158684.62    28.407305    28.407305 
   39000   -36223.895   -36223.895   -36528.247   -36528.247    294.35773    294.35773    158736.45    158736.45   -203.80411   -203.80411 
Loop time of 136.611 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.947 hours/ns, 7.320 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.93     | 135.93     | 135.93     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057274   | 0.057274   | 0.057274   |   0.0 |  0.04
Output  | 0.00012359 | 0.00012359 | 0.00012359 |   0.0 |  0.00
Modify  | 0.55839    | 0.55839    | 0.55839    |   0.0 |  0.41
Other   |            | 0.06223    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385520.0 ave      385520 max      385520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385520
Ave neighs/atom = 48.190000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.847564811544, Press = -0.0290695418764328
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -36223.895   -36223.895   -36528.247   -36528.247    294.35773    294.35773    158736.45    158736.45   -203.80411   -203.80411 
   40000   -36225.313   -36225.313   -36531.648   -36531.648    296.27522    296.27522    158757.73    158757.73   -51.573022   -51.573022 
Loop time of 136.66 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.961 hours/ns, 7.317 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.98     | 135.98     | 135.98     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057406   | 0.057406   | 0.057406   |   0.0 |  0.04
Output  | 0.0001251  | 0.0001251  | 0.0001251  |   0.0 |  0.00
Modify  | 0.55817    | 0.55817    | 0.55817    |   0.0 |  0.41
Other   |            | 0.06242    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385440.0 ave      385440 max      385440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385440
Ave neighs/atom = 48.180000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.89372832134, Press = 0.680153957199856
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -36225.313   -36225.313   -36531.648   -36531.648    296.27522    296.27522    158757.73    158757.73   -51.573022   -51.573022 
   41000   -36228.464   -36228.464   -36535.021   -36535.021    296.49034    296.49034    158747.47    158747.47    61.273308    61.273308 
Loop time of 136.56 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.633 ns/day, 37.933 hours/ns, 7.323 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.88     | 135.88     | 135.88     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057796   | 0.057796   | 0.057796   |   0.0 |  0.04
Output  | 0.00014161 | 0.00014161 | 0.00014161 |   0.0 |  0.00
Modify  | 0.55826    | 0.55826    | 0.55826    |   0.0 |  0.41
Other   |            | 0.06236    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385058.0 ave      385058 max      385058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385058
Ave neighs/atom = 48.132250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.902865210197, Press = -0.398189778617767
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -36228.464   -36228.464   -36535.021   -36535.021    296.49034    296.49034    158747.47    158747.47    61.273308    61.273308 
   42000   -36234.212   -36234.212   -36535.349   -36535.349    291.24872    291.24872    158774.29    158774.29     -289.707     -289.707 
Loop time of 136.611 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.948 hours/ns, 7.320 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.93     | 135.93     | 135.93     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05742    | 0.05742    | 0.05742    |   0.0 |  0.04
Output  | 0.00012388 | 0.00012388 | 0.00012388 |   0.0 |  0.00
Modify  | 0.55817    | 0.55817    | 0.55817    |   0.0 |  0.41
Other   |            | 0.06219    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384532.0 ave      384532 max      384532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384532
Ave neighs/atom = 48.066500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.907778231969, Press = -0.412576481216759
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -36234.212   -36234.212   -36535.349   -36535.349    291.24872    291.24872    158774.29    158774.29     -289.707     -289.707 
   43000   -36227.073   -36227.073    -36532.99    -36532.99     295.8721     295.8721    158483.44    158483.44    1004.8813    1004.8813 
Loop time of 136.737 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.983 hours/ns, 7.313 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.06     | 136.06     | 136.06     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057249   | 0.057249   | 0.057249   |   0.0 |  0.04
Output  | 0.00013275 | 0.00013275 | 0.00013275 |   0.0 |  0.00
Modify  | 0.55539    | 0.55539    | 0.55539    |   0.0 |  0.41
Other   |            | 0.06112    |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384774.0 ave      384774 max      384774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384774
Ave neighs/atom = 48.096750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.885444307172, Press = 0.260361915869943
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -36227.073   -36227.073    -36532.99    -36532.99     295.8721     295.8721    158483.44    158483.44    1004.8813    1004.8813 
   44000   -36234.983   -36234.983    -36537.27    -36537.27    292.36054    292.36054    158669.94    158669.94    414.92646    414.92646 
Loop time of 136.616 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.949 hours/ns, 7.320 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.94     | 135.94     | 135.94     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05773    | 0.05773    | 0.05773    |   0.0 |  0.04
Output  | 0.00019824 | 0.00019824 | 0.00019824 |   0.0 |  0.00
Modify  | 0.55674    | 0.55674    | 0.55674    |   0.0 |  0.41
Other   |            | 0.06271    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386430.0 ave      386430 max      386430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386430
Ave neighs/atom = 48.303750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.874892974488, Press = 0.694208313535384
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -36234.983   -36234.983    -36537.27    -36537.27    292.36054    292.36054    158669.94    158669.94    414.92646    414.92646 
   45000   -36226.629   -36226.629   -36532.649   -36532.649    295.97199    295.97199    158724.14    158724.14    16.956947    16.956947 
Loop time of 136.503 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.633 ns/day, 37.917 hours/ns, 7.326 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.83     | 135.83     | 135.83     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058153   | 0.058153   | 0.058153   |   0.0 |  0.04
Output  | 0.00011583 | 0.00011583 | 0.00011583 |   0.0 |  0.00
Modify  | 0.55609    | 0.55609    | 0.55609    |   0.0 |  0.41
Other   |            | 0.06348    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385008.0 ave      385008 max      385008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385008
Ave neighs/atom = 48.126000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.853284284023, Press = -0.148019685540373
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -36226.629   -36226.629   -36532.649   -36532.649    295.97199    295.97199    158724.14    158724.14    16.956947    16.956947 
   46000   -36225.616   -36225.616   -36535.101   -36535.101    299.32165    299.32165    158661.53    158661.53    122.23709    122.23709 
Loop time of 136.58 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.633 ns/day, 37.939 hours/ns, 7.322 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.9      | 135.9      | 135.9      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058217   | 0.058217   | 0.058217   |   0.0 |  0.04
Output  | 0.00012692 | 0.00012692 | 0.00012692 |   0.0 |  0.00
Modify  | 0.55641    | 0.55641    | 0.55641    |   0.0 |  0.41
Other   |            | 0.06371    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384962.0 ave      384962 max      384962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384962
Ave neighs/atom = 48.120250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.883640096489, Press = -0.087361524485739
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -36225.616   -36225.616   -36535.101   -36535.101    299.32165    299.32165    158661.53    158661.53    122.23709    122.23709 
   47000   -36226.774   -36226.774   -36528.304   -36528.304    291.62872    291.62872    158729.97    158729.97   -145.92322   -145.92322 
Loop time of 136.588 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.633 ns/day, 37.941 hours/ns, 7.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    | 135.91     | 135.91     | 135.91     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057905   | 0.057905   | 0.057905   |   0.0 |  0.04
Output  | 0.00011604 | 0.00011604 | 0.00011604 |   0.0 |  0.00
Modify  | 0.55616    | 0.55616    | 0.55616    |   0.0 |  0.41
Other   |            | 0.06377    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385476.0 ave      385476 max      385476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385476
Ave neighs/atom = 48.184500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.896015673044, Press = -0.0516812517973308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -36226.774   -36226.774   -36528.304   -36528.304    291.62872    291.62872    158729.97    158729.97   -145.92322   -145.92322 
   48000   -36233.482   -36233.482    -36533.05    -36533.05    289.73099    289.73099    158936.23    158936.23    -1239.554    -1239.554 
Loop time of 136.514 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.633 ns/day, 37.921 hours/ns, 7.325 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.84     | 135.84     | 135.84     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057757   | 0.057757   | 0.057757   |   0.0 |  0.04
Output  | 0.00011473 | 0.00011473 | 0.00011473 |   0.0 |  0.00
Modify  | 0.55422    | 0.55422    | 0.55422    |   0.0 |  0.41
Other   |            | 0.06342    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385446.0 ave      385446 max      385446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385446
Ave neighs/atom = 48.180750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.905941770842, Press = -0.372502078065478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -36233.482   -36233.482    -36533.05    -36533.05    289.73099    289.73099    158936.23    158936.23    -1239.554    -1239.554 
   49000   -36225.459   -36225.459   -36527.519   -36527.519    292.14205    292.14205    158642.82    158642.82    253.63514    253.63514 
Loop time of 136.56 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.633 ns/day, 37.933 hours/ns, 7.323 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.88     | 135.88     | 135.88     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058196   | 0.058196   | 0.058196   |   0.0 |  0.04
Output  | 0.00012383 | 0.00012383 | 0.00012383 |   0.0 |  0.00
Modify  | 0.55621    | 0.55621    | 0.55621    |   0.0 |  0.41
Other   |            | 0.06365    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384510.0 ave      384510 max      384510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384510
Ave neighs/atom = 48.063750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.891896887434, Press = -0.296983941006427
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -36225.459   -36225.459   -36527.519   -36527.519    292.14205    292.14205    158642.82    158642.82    253.63514    253.63514 
   50000    -36233.56    -36233.56   -36532.792   -36532.792    289.40627    289.40627     158589.8     158589.8    633.49116    633.49116 
Loop time of 136.645 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.632 ns/day, 37.957 hours/ns, 7.318 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.97     | 135.97     | 135.97     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057894   | 0.057894   | 0.057894   |   0.0 |  0.04
Output  | 0.00011672 | 0.00011672 | 0.00011672 |   0.0 |  0.00
Modify  | 0.55519    | 0.55519    | 0.55519    |   0.0 |  0.41
Other   |            | 0.06361    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386040.0 ave      386040 max      386040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386040
Ave neighs/atom = 48.255000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.878664686825, Press = 0.48306810939671
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -36233.56    -36233.56   -36532.792   -36532.792    289.40627    289.40627     158589.8     158589.8    633.49116    633.49116 
   51000   -36227.426   -36227.426   -36532.377   -36532.377     294.9376     294.9376    158728.96    158728.96   -151.92604   -151.92604 
Loop time of 136.551 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.633 ns/day, 37.931 hours/ns, 7.323 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.87     | 135.87     | 135.87     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058036   | 0.058036   | 0.058036   |   0.0 |  0.04
Output  | 0.00012188 | 0.00012188 | 0.00012188 |   0.0 |  0.00
Modify  | 0.5564     | 0.5564     | 0.5564     |   0.0 |  0.41
Other   |            | 0.06376    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385992.0 ave      385992 max      385992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385992
Ave neighs/atom = 48.249000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.881829645777, Press = 0.0296845260701741
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -36227.426   -36227.426   -36532.377   -36532.377     294.9376     294.9376    158728.96    158728.96   -151.92604   -151.92604 
   52000   -36230.407   -36230.407   -36534.206   -36534.206      293.823      293.823    158702.21    158702.21    135.16425    135.16425 
Loop time of 142.602 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.606 ns/day, 39.612 hours/ns, 7.013 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.89     | 141.89     | 141.89     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060609   | 0.060609   | 0.060609   |   0.0 |  0.04
Output  | 0.00022338 | 0.00022338 | 0.00022338 |   0.0 |  0.00
Modify  | 0.58073    | 0.58073    | 0.58073    |   0.0 |  0.41
Other   |            | 0.06664    |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385442.0 ave      385442 max      385442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385442
Ave neighs/atom = 48.180250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.886106035401, Press = -0.0642683612393407
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -36230.407   -36230.407   -36534.206   -36534.206      293.823      293.823    158702.21    158702.21    135.16425    135.16425 
   53000   -36233.535   -36233.535   -36531.855   -36531.855    288.52416    288.52416     158637.8     158637.8    320.52237    320.52237 
Loop time of 283.824 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.840 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.42     | 282.42     | 282.42     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11999    | 0.11999    | 0.11999    |   0.0 |  0.04
Output  | 0.00033742 | 0.00033742 | 0.00033742 |   0.0 |  0.00
Modify  | 1.155      | 1.155      | 1.155      |   0.0 |  0.41
Other   |            | 0.1299     |            |       |  0.05

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385224.0 ave      385224 max      385224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385224
Ave neighs/atom = 48.153000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.856882122751, Press = -0.0145662195759714
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -36233.535   -36233.535   -36531.855   -36531.855    288.52416    288.52416     158637.8     158637.8    320.52237    320.52237 
   54000   -36228.038   -36228.038   -36531.761   -36531.761     293.7496     293.7496    158600.07    158600.07    429.61854    429.61854 
Loop time of 283.864 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.851 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.47     | 282.47     | 282.47     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11776    | 0.11776    | 0.11776    |   0.0 |  0.04
Output  | 0.00020635 | 0.00020635 | 0.00020635 |   0.0 |  0.00
Modify  | 1.1483     | 1.1483     | 1.1483     |   0.0 |  0.40
Other   |            | 0.1232     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385972.0 ave      385972 max      385972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385972
Ave neighs/atom = 48.246500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.859312447887, Press = 0.39983469286158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -36228.038   -36228.038   -36531.761   -36531.761     293.7496     293.7496    158600.07    158600.07    429.61854    429.61854 
   55000   -36227.836   -36227.836   -36532.004   -36532.004    294.17998    294.17998    158768.94    158768.94   -411.54402   -411.54402 
Loop time of 283.927 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.868 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.54     | 282.54     | 282.54     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11784    | 0.11784    | 0.11784    |   0.0 |  0.04
Output  | 0.00019922 | 0.00019922 | 0.00019922 |   0.0 |  0.00
Modify  | 1.1494     | 1.1494     | 1.1494     |   0.0 |  0.40
Other   |            | 0.1237     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385838.0 ave      385838 max      385838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385838
Ave neighs/atom = 48.229750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.841213812493, Press = -0.0552422869948791
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -36227.836   -36227.836   -36532.004   -36532.004    294.17998    294.17998    158768.94    158768.94   -411.54402   -411.54402 
   56000   -36231.059   -36231.059    -36533.93    -36533.93    292.92553    292.92553    158745.52    158745.52    -117.0407    -117.0407 
Loop time of 283.867 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.852 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.48     | 282.48     | 282.48     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11798    | 0.11798    | 0.11798    |   0.0 |  0.04
Output  | 0.00022103 | 0.00022103 | 0.00022103 |   0.0 |  0.00
Modify  | 1.1495     | 1.1495     | 1.1495     |   0.0 |  0.40
Other   |            | 0.1234     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385280.0 ave      385280 max      385280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385280
Ave neighs/atom = 48.160000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831949685807, Press = -0.363550177071051
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -36231.059   -36231.059    -36533.93    -36533.93    292.92553    292.92553    158745.52    158745.52    -117.0407    -117.0407 
   57000   -36227.382   -36227.382   -36532.965   -36532.965      295.549      295.549    158671.48    158671.48    71.723522    71.723522 
Loop time of 283.925 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.868 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.53     | 282.53     | 282.53     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11856    | 0.11856    | 0.11856    |   0.0 |  0.04
Output  | 0.00020154 | 0.00020154 | 0.00020154 |   0.0 |  0.00
Modify  | 1.1505     | 1.1505     | 1.1505     |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385100.0 ave      385100 max      385100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385100
Ave neighs/atom = 48.137500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.810487437298, Press = 0.247021166387492
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -36227.382   -36227.382   -36532.965   -36532.965      295.549      295.549    158671.48    158671.48    71.723522    71.723522 
   58000   -36234.926   -36234.926   -36536.399   -36536.399    291.57359    291.57359    158834.65    158834.65   -501.10485   -501.10485 
Loop time of 283.894 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.859 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.5      | 282.5      | 282.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11867    | 0.11867    | 0.11867    |   0.0 |  0.04
Output  | 0.00021354 | 0.00021354 | 0.00021354 |   0.0 |  0.00
Modify  | 1.1513     | 1.1513     | 1.1513     |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385728.0 ave      385728 max      385728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385728
Ave neighs/atom = 48.216000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.80747546014, Press = -0.212939884859706
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -36234.926   -36234.926   -36536.399   -36536.399    291.57359    291.57359    158834.65    158834.65   -501.10485   -501.10485 
   59000   -36227.989   -36227.989   -36531.926   -36531.926    293.95715    293.95715    158851.15    158851.15   -628.96739   -628.96739 
Loop time of 283.894 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.860 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.5      | 282.5      | 282.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11812    | 0.11812    | 0.11812    |   0.0 |  0.04
Output  | 0.00020324 | 0.00020324 | 0.00020324 |   0.0 |  0.00
Modify  | 1.1517     | 1.1517     | 1.1517     |   0.0 |  0.41
Other   |            | 0.1237     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384530.0 ave      384530 max      384530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384530
Ave neighs/atom = 48.066250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.810333868292, Press = -0.421356550836162
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -36227.989   -36227.989   -36531.926   -36531.926    293.95715    293.95715    158851.15    158851.15   -628.96739   -628.96739 
   60000   -36224.383   -36224.383   -36526.358   -36526.358    292.05862    292.05862     158699.3     158699.3   -240.33587   -240.33587 
Loop time of 284.109 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.919 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.71     | 282.71     | 282.71     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11849    | 0.11849    | 0.11849    |   0.0 |  0.04
Output  | 0.00019217 | 0.00019217 | 0.00019217 |   0.0 |  0.00
Modify  | 1.1531     | 1.1531     | 1.1531     |   0.0 |  0.41
Other   |            | 0.1243     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384840.0 ave      384840 max      384840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384840
Ave neighs/atom = 48.105000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.816761317639, Press = -0.212156719551418
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -36224.383   -36224.383   -36526.358   -36526.358    292.05862    292.05862     158699.3     158699.3   -240.33587   -240.33587 
   61000   -36227.711   -36227.711   -36530.443   -36530.443    292.79168    292.79168     158807.6     158807.6   -595.25049   -595.25049 
Loop time of 284.065 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.907 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.68     | 282.68     | 282.68     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1175     | 0.1175     | 0.1175     |   0.0 |  0.04
Output  | 0.00019997 | 0.00019997 | 0.00019997 |   0.0 |  0.00
Modify  | 1.1475     | 1.1475     | 1.1475     |   0.0 |  0.40
Other   |            | 0.1232     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386274.0 ave      386274 max      386274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386274
Ave neighs/atom = 48.284250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837952928718, Press = 0.0632633387224897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -36227.711   -36227.711   -36530.443   -36530.443    292.79168    292.79168     158807.6     158807.6   -595.25049   -595.25049 
   62000   -36235.223   -36235.223   -36532.819   -36532.819    287.82352    287.82352    158651.82    158651.82    238.54753    238.54753 
Loop time of 283.909 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.864 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.52     | 282.52     | 282.52     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11727    | 0.11727    | 0.11727    |   0.0 |  0.04
Output  | 0.00021351 | 0.00021351 | 0.00021351 |   0.0 |  0.00
Modify  | 1.1485     | 1.1485     | 1.1485     |   0.0 |  0.40
Other   |            | 0.1234     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385302.0 ave      385302 max      385302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385302
Ave neighs/atom = 48.162750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.825339816372, Press = -0.195951903405231
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -36235.223   -36235.223   -36532.819   -36532.819    287.82352    287.82352    158651.82    158651.82    238.54753    238.54753 
   63000   -36226.498   -36226.498   -36530.249   -36530.249    293.77601    293.77601     158714.6     158714.6   -193.70694   -193.70694 
Loop time of 283.892 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.859 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.5      | 282.5      | 282.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11784    | 0.11784    | 0.11784    |   0.0 |  0.04
Output  | 0.00021047 | 0.00021047 | 0.00021047 |   0.0 |  0.00
Modify  | 1.1495     | 1.1495     | 1.1495     |   0.0 |  0.40
Other   |            | 0.1239     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6729.00 ave        6729 max        6729 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385746.0 ave      385746 max      385746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385746
Ave neighs/atom = 48.218250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818311878325, Press = -0.155051623231403
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -36226.498   -36226.498   -36530.249   -36530.249    293.77601    293.77601     158714.6     158714.6   -193.70694   -193.70694 
   64000   -36233.077   -36233.077   -36535.077   -36535.077    292.08403    292.08403    158744.71    158744.71   -167.18583   -167.18583 
Loop time of 283.83 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.842 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.44     | 282.44     | 282.44     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11814    | 0.11814    | 0.11814    |   0.0 |  0.04
Output  | 0.0002154  | 0.0002154  | 0.0002154  |   0.0 |  0.00
Modify  | 1.1497     | 1.1497     | 1.1497     |   0.0 |  0.41
Other   |            | 0.1235     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385656.0 ave      385656 max      385656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385656
Ave neighs/atom = 48.207000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.811388906057, Press = -0.281363042579976
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -36233.077   -36233.077   -36535.077   -36535.077    292.08403    292.08403    158744.71    158744.71   -167.18583   -167.18583 
   65000   -36226.775   -36226.775   -36528.618   -36528.618    291.93109    291.93109    158570.73    158570.73    559.18223    559.18223 
Loop time of 283.869 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.853 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.47     | 282.47     | 282.47     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11841    | 0.11841    | 0.11841    |   0.0 |  0.04
Output  | 0.00020589 | 0.00020589 | 0.00020589 |   0.0 |  0.00
Modify  | 1.1528     | 1.1528     | 1.1528     |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385314.0 ave      385314 max      385314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385314
Ave neighs/atom = 48.164250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.801045631369, Press = -0.137622207866801
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -36226.775   -36226.775   -36528.618   -36528.618    291.93109    291.93109    158570.73    158570.73    559.18223    559.18223 
   66000   -36234.593   -36234.593   -36534.339   -36534.339    289.90268    289.90268    158573.59    158573.59    619.13744    619.13744 
Loop time of 284.157 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.933 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.76     | 282.76     | 282.76     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11833    | 0.11833    | 0.11833    |   0.0 |  0.04
Output  | 0.00020074 | 0.00020074 | 0.00020074 |   0.0 |  0.00
Modify  | 1.1515     | 1.1515     | 1.1515     |   0.0 |  0.41
Other   |            | 0.1241     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386180.0 ave      386180 max      386180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386180
Ave neighs/atom = 48.272500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.794735357457, Press = 0.155845416622183
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -36234.593   -36234.593   -36534.339   -36534.339    289.90268    289.90268    158573.59    158573.59    619.13744    619.13744 
   67000   -36229.032   -36229.032   -36529.301   -36529.301    290.40919    290.40919    158772.52    158772.52   -460.44694   -460.44694 
Loop time of 284.019 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.894 hours/ns, 3.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.62     | 282.62     | 282.62     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11887    | 0.11887    | 0.11887    |   0.0 |  0.04
Output  | 0.00020707 | 0.00020707 | 0.00020707 |   0.0 |  0.00
Modify  | 1.1521     | 1.1521     | 1.1521     |   0.0 |  0.41
Other   |            | 0.1237     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385976.0 ave      385976 max      385976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385976
Ave neighs/atom = 48.247000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.80000436816, Press = 0.218281771233707
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -36229.032   -36229.032   -36529.301   -36529.301    290.40919    290.40919    158772.52    158772.52   -460.44694   -460.44694 
   68000   -36220.973   -36220.973    -36527.99    -36527.99    296.93563    296.93563    158829.27    158829.27   -723.23371   -723.23371 
Loop time of 283.772 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.825 hours/ns, 3.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.38     | 282.38     | 282.38     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11885    | 0.11885    | 0.11885    |   0.0 |  0.04
Output  | 0.00019235 | 0.00019235 | 0.00019235 |   0.0 |  0.00
Modify  | 1.1529     | 1.1529     | 1.1529     |   0.0 |  0.41
Other   |            | 0.1241     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385430.0 ave      385430 max      385430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385430
Ave neighs/atom = 48.178750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.810435424288, Press = -0.158682422977381
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -36220.973   -36220.973    -36527.99    -36527.99    296.93563    296.93563    158829.27    158829.27   -723.23371   -723.23371 
   69000   -36228.258   -36228.258   -36529.827   -36529.827    291.66722    291.66722    158770.34    158770.34   -193.54856   -193.54856 
Loop time of 283.919 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.866 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.53     | 282.53     | 282.53     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11742    | 0.11742    | 0.11742    |   0.0 |  0.04
Output  | 0.00020049 | 0.00020049 | 0.00020049 |   0.0 |  0.00
Modify  | 1.1479     | 1.1479     | 1.1479     |   0.0 |  0.40
Other   |            | 0.1235     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385266.0 ave      385266 max      385266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385266
Ave neighs/atom = 48.158250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828911332, Press = -0.265869494347913
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -36228.258   -36228.258   -36529.827   -36529.827    291.66722    291.66722    158770.34    158770.34   -193.54856   -193.54856 
   70000   -36228.057   -36228.057   -36533.841   -36533.841    295.74258    295.74258    158612.52    158612.52    572.78229    572.78229 
Loop time of 283.811 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.836 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.42     | 282.42     | 282.42     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11779    | 0.11779    | 0.11779    |   0.0 |  0.04
Output  | 0.00020071 | 0.00020071 | 0.00020071 |   0.0 |  0.00
Modify  | 1.1482     | 1.1482     | 1.1482     |   0.0 |  0.40
Other   |            | 0.1234     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385098.0 ave      385098 max      385098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385098
Ave neighs/atom = 48.137250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831653518947, Press = -0.224643526730728
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -36228.057   -36228.057   -36533.841   -36533.841    295.74258    295.74258    158612.52    158612.52    572.78229    572.78229 
   71000   -36226.749   -36226.749   -36532.736   -36532.736    295.93934    295.93934    158600.86    158600.86    678.19506    678.19506 
Loop time of 283.841 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.845 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.45     | 282.45     | 282.45     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11764    | 0.11764    | 0.11764    |   0.0 |  0.04
Output  | 0.00020134 | 0.00020134 | 0.00020134 |   0.0 |  0.00
Modify  | 1.1495     | 1.1495     | 1.1495     |   0.0 |  0.40
Other   |            | 0.1239     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385778.0 ave      385778 max      385778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385778
Ave neighs/atom = 48.222250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.817156317148, Press = 0.00966482874666198
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -36226.749   -36226.749   -36532.736   -36532.736    295.93934    295.93934    158600.86    158600.86    678.19506    678.19506 
   72000   -36229.202   -36229.202   -36531.954   -36531.954    292.81041    292.81041     158763.7     158763.7   -281.44146   -281.44146 
Loop time of 283.885 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.857 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.49     | 282.49     | 282.49     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11882    | 0.11882    | 0.11882    |   0.0 |  0.04
Output  | 0.00020298 | 0.00020298 | 0.00020298 |   0.0 |  0.00
Modify  | 1.1498     | 1.1498     | 1.1498     |   0.0 |  0.41
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385386.0 ave      385386 max      385386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385386
Ave neighs/atom = 48.173250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.826224601167, Press = -0.0830002421920703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -36229.202   -36229.202   -36531.954   -36531.954    292.81041    292.81041     158763.7     158763.7   -281.44146   -281.44146 
   73000   -36220.594   -36220.594   -36527.184   -36527.184    296.52268    296.52268    158586.05    158586.05    527.78825    527.78825 
Loop time of 283.978 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.883 hours/ns, 3.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.58     | 282.58     | 282.58     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11825    | 0.11825    | 0.11825    |   0.0 |  0.04
Output  | 0.00020578 | 0.00020578 | 0.00020578 |   0.0 |  0.00
Modify  | 1.1509     | 1.1509     | 1.1509     |   0.0 |  0.41
Other   |            | 0.1237     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385222.0 ave      385222 max      385222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385222
Ave neighs/atom = 48.152750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.842056825469, Press = -0.288223543650656
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -36220.594   -36220.594   -36527.184   -36527.184    296.52268    296.52268    158586.05    158586.05    527.78825    527.78825 
   74000   -36230.461   -36230.461   -36531.859   -36531.859    291.50141    291.50141    158639.85    158639.85    106.66332    106.66332 
Loop time of 284.143 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.929 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.75     | 282.75     | 282.75     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11844    | 0.11844    | 0.11844    |   0.0 |  0.04
Output  | 0.00020055 | 0.00020055 | 0.00020055 |   0.0 |  0.00
Modify  | 1.1515     | 1.1515     | 1.1515     |   0.0 |  0.41
Other   |            | 0.1237     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6730.00 ave        6730 max        6730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386350.0 ave      386350 max      386350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386350
Ave neighs/atom = 48.293750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.846356271072, Press = 0.0789192542695218
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -36230.461   -36230.461   -36531.859   -36531.859    291.50141    291.50141    158639.85    158639.85    106.66332    106.66332 
   75000   -36231.436   -36231.436   -36533.543   -36533.543    292.18641    292.18641    158849.72    158849.72   -777.50798   -777.50798 
Loop time of 284.122 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.923 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.73     | 282.73     | 282.73     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11888    | 0.11888    | 0.11888    |   0.0 |  0.04
Output  | 0.0002035  | 0.0002035  | 0.0002035  |   0.0 |  0.00
Modify  | 1.152      | 1.152      | 1.152      |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386116.0 ave      386116 max      386116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386116
Ave neighs/atom = 48.264500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.848080507127, Press = 0.236574827203674
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -36231.436   -36231.436   -36533.543   -36533.543    292.18641    292.18641    158849.72    158849.72   -777.50798   -777.50798 
   76000   -36224.987   -36224.987   -36529.117   -36529.117    294.14348    294.14348    158697.65    158697.65   -198.46287   -198.46287 
Loop time of 284.103 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.917 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.71     | 282.71     | 282.71     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11934    | 0.11934    | 0.11934    |   0.0 |  0.04
Output  | 0.00019254 | 0.00019254 | 0.00019254 |   0.0 |  0.00
Modify  | 1.1525     | 1.1525     | 1.1525     |   0.0 |  0.41
Other   |            | 0.1244     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384896.0 ave      384896 max      384896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384896
Ave neighs/atom = 48.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.853046122587, Press = -0.214177339906332
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -36224.987   -36224.987   -36529.117   -36529.117    294.14348    294.14348    158697.65    158697.65   -198.46287   -198.46287 
   77000   -36235.481   -36235.481   -36536.668   -36536.668     291.2974     291.2974    158677.63    158677.63    257.13027    257.13027 
Loop time of 284.086 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.913 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.7      | 282.7      | 282.7      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11756    | 0.11756    | 0.11756    |   0.0 |  0.04
Output  | 0.00019939 | 0.00019939 | 0.00019939 |   0.0 |  0.00
Modify  | 1.1481     | 1.1481     | 1.1481     |   0.0 |  0.40
Other   |            | 0.1232     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385912.0 ave      385912 max      385912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385912
Ave neighs/atom = 48.239000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.840675794822, Press = -0.0816316766002491
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -36235.481   -36235.481   -36536.668   -36536.668     291.2974     291.2974    158677.63    158677.63    257.13027    257.13027 
   78000   -36222.642   -36222.642   -36529.068   -36529.068    296.36453    296.36453    158517.48    158517.48    807.82691    807.82691 
Loop time of 284.074 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.909 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.68     | 282.68     | 282.68     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11748    | 0.11748    | 0.11748    |   0.0 |  0.04
Output  | 0.00019859 | 0.00019859 | 0.00019859 |   0.0 |  0.00
Modify  | 1.1488     | 1.1488     | 1.1488     |   0.0 |  0.40
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385362.0 ave      385362 max      385362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385362
Ave neighs/atom = 48.170250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.845408826295, Press = -0.217297950190568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -36222.642   -36222.642   -36529.068   -36529.068    296.36453    296.36453    158517.48    158517.48    807.82691    807.82691 
   79000   -36230.329   -36230.329   -36533.359   -36533.359    293.07968    293.07968    158591.58    158591.58    630.61448    630.61448 
Loop time of 284.215 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.949 hours/ns, 3.518 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.82     | 282.82     | 282.82     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11804    | 0.11804    | 0.11804    |   0.0 |  0.04
Output  | 0.00020017 | 0.00020017 | 0.00020017 |   0.0 |  0.00
Modify  | 1.1494     | 1.1494     | 1.1494     |   0.0 |  0.40
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386562.0 ave      386562 max      386562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386562
Ave neighs/atom = 48.320250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.860837776542, Press = -0.0131489056850646
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -36230.329   -36230.329   -36533.359   -36533.359    293.07968    293.07968    158591.58    158591.58    630.61448    630.61448 
   80000   -36218.531   -36218.531   -36524.213   -36524.213    295.64482    295.64482    158596.65    158596.65    197.84477    197.84477 
Loop time of 284.056 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.905 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.66     | 282.66     | 282.66     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11838    | 0.11838    | 0.11838    |   0.0 |  0.04
Output  | 0.00020284 | 0.00020284 | 0.00020284 |   0.0 |  0.00
Modify  | 1.15       | 1.15       | 1.15       |   0.0 |  0.40
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385834.0 ave      385834 max      385834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385834
Ave neighs/atom = 48.229250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.877122581912, Press = 0.0786046336481633
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -36218.531   -36218.531   -36524.213   -36524.213    295.64482    295.64482    158596.65    158596.65    197.84477    197.84477 
   81000   -36228.611   -36228.611    -36529.27    -36529.27    290.78631    290.78631    158664.25    158664.25   -88.289775   -88.289775 
Loop time of 284.116 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.921 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.72     | 282.72     | 282.72     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11842    | 0.11842    | 0.11842    |   0.0 |  0.04
Output  | 0.00020037 | 0.00020037 | 0.00020037 |   0.0 |  0.00
Modify  | 1.1505     | 1.1505     | 1.1505     |   0.0 |  0.40
Other   |            | 0.1235     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386888.0 ave      386888 max      386888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386888
Ave neighs/atom = 48.361000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.885074525173, Press = -0.0996432693751592
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -36228.611   -36228.611    -36529.27    -36529.27    290.78631    290.78631    158664.25    158664.25   -88.289775   -88.289775 
   82000   -36228.848   -36228.848   -36528.382   -36528.382    289.69911    289.69911    158724.97    158724.97    9.9202309    9.9202309 
Loop time of 284.172 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.937 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.78     | 282.78     | 282.78     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11848    | 0.11848    | 0.11848    |   0.0 |  0.04
Output  | 0.00020088 | 0.00020088 | 0.00020088 |   0.0 |  0.00
Modify  | 1.1517     | 1.1517     | 1.1517     |   0.0 |  0.41
Other   |            | 0.1239     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386168.0 ave      386168 max      386168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386168
Ave neighs/atom = 48.271000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.893393524984, Press = 0.001015419291215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -36228.848   -36228.848   -36528.382   -36528.382    289.69911    289.69911    158724.97    158724.97    9.9202309    9.9202309 
   83000   -36227.378   -36227.378   -36531.555   -36531.555    294.18883    294.18883    158659.18    158659.18    74.453363    74.453363 
Loop time of 284.1 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.917 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.7      | 282.7      | 282.7      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11899    | 0.11899    | 0.11899    |   0.0 |  0.04
Output  | 0.00020552 | 0.00020552 | 0.00020552 |   0.0 |  0.00
Modify  | 1.1522     | 1.1522     | 1.1522     |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384928.0 ave      384928 max      384928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384928
Ave neighs/atom = 48.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.894793879392, Press = -0.0883191163141073
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -36227.378   -36227.378   -36531.555   -36531.555    294.18883    294.18883    158659.18    158659.18    74.453363    74.453363 
   84000   -36224.775   -36224.775   -36527.334   -36527.334    292.62386    292.62386    158572.04    158572.04    446.48539    446.48539 
Loop time of 284.267 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.963 hours/ns, 3.518 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.87     | 282.87     | 282.87     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11884    | 0.11884    | 0.11884    |   0.0 |  0.04
Output  | 0.00018519 | 0.00018519 | 0.00018519 |   0.0 |  0.00
Modify  | 1.1529     | 1.1529     | 1.1529     |   0.0 |  0.41
Other   |            | 0.1244     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385656.0 ave      385656 max      385656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385656
Ave neighs/atom = 48.207000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.896698981096, Press = -0.09842129347481
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -36224.775   -36224.775   -36527.334   -36527.334    292.62386    292.62386    158572.04    158572.04    446.48539    446.48539 
   85000    -36226.05    -36226.05   -36530.791   -36530.791    294.73407    294.73407    158743.48    158743.48   -295.79205   -295.79205 
Loop time of 284.04 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.900 hours/ns, 3.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.65     | 282.65     | 282.65     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11803    | 0.11803    | 0.11803    |   0.0 |  0.04
Output  | 0.00019793 | 0.00019793 | 0.00019793 |   0.0 |  0.00
Modify  | 1.1478     | 1.1478     | 1.1478     |   0.0 |  0.40
Other   |            | 0.1232     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386360.0 ave      386360 max      386360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386360
Ave neighs/atom = 48.295000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.888450859289, Press = 0.13449285377922
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000    -36226.05    -36226.05   -36530.791   -36530.791    294.73407    294.73407    158743.48    158743.48   -295.79205   -295.79205 
   86000   -36231.465   -36231.465   -36535.812   -36535.812    294.35387    294.35387    158622.45    158622.45    394.31256    394.31256 
Loop time of 283.852 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.848 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.46     | 282.46     | 282.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11756    | 0.11756    | 0.11756    |   0.0 |  0.04
Output  | 0.00020843 | 0.00020843 | 0.00020843 |   0.0 |  0.00
Modify  | 1.1488     | 1.1488     | 1.1488     |   0.0 |  0.40
Other   |            | 0.1232     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385462.0 ave      385462 max      385462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385462
Ave neighs/atom = 48.182750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.884793175948, Press = -0.133660258123154
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -36231.465   -36231.465   -36535.812   -36535.812    294.35387    294.35387    158622.45    158622.45    394.31256    394.31256 
   87000   -36224.986   -36224.986   -36529.538   -36529.538     294.5512     294.5512    158725.71    158725.71   -272.42121   -272.42121 
Loop time of 283.852 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.848 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.46     | 282.46     | 282.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11756    | 0.11756    | 0.11756    |   0.0 |  0.04
Output  | 0.0002135  | 0.0002135  | 0.0002135  |   0.0 |  0.00
Modify  | 1.1498     | 1.1498     | 1.1498     |   0.0 |  0.41
Other   |            | 0.1234     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385656.0 ave      385656 max      385656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385656
Ave neighs/atom = 48.207000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.888899946696, Press = -0.0383571152734245
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -36224.986   -36224.986   -36529.538   -36529.538     294.5512     294.5512    158725.71    158725.71   -272.42121   -272.42121 
   88000    -36231.21    -36231.21   -36531.978   -36531.978    290.89208    290.89208    158653.24    158653.24    378.35337    378.35337 
Loop time of 283.885 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.857 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.49     | 282.49     | 282.49     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11807    | 0.11807    | 0.11807    |   0.0 |  0.04
Output  | 0.00019981 | 0.00019981 | 0.00019981 |   0.0 |  0.00
Modify  | 1.1501     | 1.1501     | 1.1501     |   0.0 |  0.41
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6728.00 ave        6728 max        6728 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385746.0 ave      385746 max      385746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385746
Ave neighs/atom = 48.218250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.9053425764, Press = -0.144503384650604
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000    -36231.21    -36231.21   -36531.978   -36531.978    290.89208    290.89208    158653.24    158653.24    378.35337    378.35337 
   89000   -36226.552   -36226.552   -36532.674   -36532.674    296.06952    296.06952    158771.46    158771.46   -139.08092   -139.08092 
Loop time of 283.988 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.886 hours/ns, 3.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.6      | 282.6      | 282.6      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11849    | 0.11849    | 0.11849    |   0.0 |  0.04
Output  | 0.00020305 | 0.00020305 | 0.00020305 |   0.0 |  0.00
Modify  | 1.1508     | 1.1508     | 1.1508     |   0.0 |  0.41
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385504.0 ave      385504 max      385504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385504
Ave neighs/atom = 48.188000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.909438316005, Press = -0.0584602585051983
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -36226.552   -36226.552   -36532.674   -36532.674    296.06952    296.06952    158771.46    158771.46   -139.08092   -139.08092 
   90000   -36237.215   -36237.215   -36538.983   -36538.983    291.85942    291.85942     158607.5     158607.5    815.10923    815.10923 
Loop time of 283.829 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.841 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.43     | 282.43     | 282.43     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11886    | 0.11886    | 0.11886    |   0.0 |  0.04
Output  | 0.00020473 | 0.00020473 | 0.00020473 |   0.0 |  0.00
Modify  | 1.1523     | 1.1523     | 1.1523     |   0.0 |  0.41
Other   |            | 0.1239     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384930.0 ave      384930 max      384930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384930
Ave neighs/atom = 48.116250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.89890907811, Press = -0.0758757196541017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -36237.215   -36237.215   -36538.983   -36538.983    291.85942    291.85942     158607.5     158607.5    815.10923    815.10923 
   91000   -36229.626   -36229.626   -36529.202   -36529.202    289.73845    289.73845     158697.5     158697.5    -26.53211    -26.53211 
Loop time of 284.024 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.896 hours/ns, 3.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.63     | 282.63     | 282.63     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11922    | 0.11922    | 0.11922    |   0.0 |  0.04
Output  | 0.00020426 | 0.00020426 | 0.00020426 |   0.0 |  0.00
Modify  | 1.1524     | 1.1524     | 1.1524     |   0.0 |  0.41
Other   |            | 0.124      |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385256.0 ave      385256 max      385256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385256
Ave neighs/atom = 48.157000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.903295191949, Press = 0.149004977928305
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -36229.626   -36229.626   -36529.202   -36529.202    289.73845    289.73845     158697.5     158697.5    -26.53211    -26.53211 
   92000   -36233.007   -36233.007   -36537.209   -36537.209    294.21207    294.21207    158796.77    158796.77   -292.82652   -292.82652 
Loop time of 284.006 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.891 hours/ns, 3.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.61     | 282.61     | 282.61     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11882    | 0.11882    | 0.11882    |   0.0 |  0.04
Output  | 0.00019999 | 0.00019999 | 0.00019999 |   0.0 |  0.00
Modify  | 1.1528     | 1.1528     | 1.1528     |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385550.0 ave      385550 max      385550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385550
Ave neighs/atom = 48.193750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.9013497899, Press = -0.0737676529357954
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -36233.007   -36233.007   -36537.209   -36537.209    294.21207    294.21207    158796.77    158796.77   -292.82652   -292.82652 
   93000   -36230.115   -36230.115   -36535.872   -36535.872    295.71676    295.71676    158710.18    158710.18    191.04883    191.04883 
Loop time of 283.813 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.837 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.42     | 282.42     | 282.42     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11748    | 0.11748    | 0.11748    |   0.0 |  0.04
Output  | 0.00020283 | 0.00020283 | 0.00020283 |   0.0 |  0.00
Modify  | 1.1483     | 1.1483     | 1.1483     |   0.0 |  0.40
Other   |            | 0.1234     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384628.0 ave      384628 max      384628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384628
Ave neighs/atom = 48.078500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.906404348488, Press = -0.0127443733266743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -36230.115   -36230.115   -36535.872   -36535.872    295.71676    295.71676    158710.18    158710.18    191.04883    191.04883 
   94000   -36230.886   -36230.886   -36528.366   -36528.366     287.7119     287.7119    158708.52    158708.52   -91.235093   -91.235093 
Loop time of 283.934 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.870 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.54     | 282.54     | 282.54     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11801    | 0.11801    | 0.11801    |   0.0 |  0.04
Output  | 0.00021184 | 0.00021184 | 0.00021184 |   0.0 |  0.00
Modify  | 1.1486     | 1.1486     | 1.1486     |   0.0 |  0.40
Other   |            | 0.1234     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384888.0 ave      384888 max      384888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384888
Ave neighs/atom = 48.111000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899340986293, Press = -0.141013173028774
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -36230.886   -36230.886   -36528.366   -36528.366     287.7119     287.7119    158708.52    158708.52   -91.235093   -91.235093 
   95000   -36224.164   -36224.164   -36528.723   -36528.723    294.55836    294.55836    158687.95    158687.95   -175.20656   -175.20656 
Loop time of 284.132 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.925 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.74     | 282.74     | 282.74     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11785    | 0.11785    | 0.11785    |   0.0 |  0.04
Output  | 0.00020247 | 0.00020247 | 0.00020247 |   0.0 |  0.00
Modify  | 1.15       | 1.15       | 1.15       |   0.0 |  0.40
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385606.0 ave      385606 max      385606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385606
Ave neighs/atom = 48.200750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.906707302615, Press = -0.0497939042444604
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -36224.164   -36224.164   -36528.723   -36528.723    294.55836    294.55836    158687.95    158687.95   -175.20656   -175.20656 
   96000   -36228.932   -36228.932   -36534.493   -36534.493    295.52732    295.52732    158622.34    158622.34    422.58786    422.58786 
Loop time of 284.071 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.909 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.68     | 282.68     | 282.68     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11859    | 0.11859    | 0.11859    |   0.0 |  0.04
Output  | 0.00019988 | 0.00019988 | 0.00019988 |   0.0 |  0.00
Modify  | 1.1524     | 1.1524     | 1.1524     |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386194.0 ave      386194 max      386194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386194
Ave neighs/atom = 48.274250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.901089900019, Press = 0.105443675321727
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -36228.932   -36228.932   -36534.493   -36534.493    295.52732    295.52732    158622.34    158622.34    422.58786    422.58786 
   97000   -36226.325   -36226.325   -36530.122   -36530.122    293.82082    293.82082    158611.87    158611.87     249.2635     249.2635 
Loop time of 284.115 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.921 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.72     | 282.72     | 282.72     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11834    | 0.11834    | 0.11834    |   0.0 |  0.04
Output  | 0.00020456 | 0.00020456 | 0.00020456 |   0.0 |  0.00
Modify  | 1.151      | 1.151      | 1.151      |   0.0 |  0.41
Other   |            | 0.1237     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385598.0 ave      385598 max      385598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385598
Ave neighs/atom = 48.199750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.902585565432, Press = 0.102993650852078
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -36226.325   -36226.325   -36530.122   -36530.122    293.82082    293.82082    158611.87    158611.87     249.2635     249.2635 
   98000   -36237.365   -36237.365    -36537.55    -36537.55    290.32765    290.32765     158826.3     158826.3   -538.40178   -538.40178 
Loop time of 284.136 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.927 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.74     | 282.74     | 282.74     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11908    | 0.11908    | 0.11908    |   0.0 |  0.04
Output  | 0.00020171 | 0.00020171 | 0.00020171 |   0.0 |  0.00
Modify  | 1.1519     | 1.1519     | 1.1519     |   0.0 |  0.41
Other   |            | 0.1239     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386120.0 ave      386120 max      386120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386120
Ave neighs/atom = 48.265000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.891871118691, Press = -0.108199465921171
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -36237.365   -36237.365    -36537.55    -36537.55    290.32765    290.32765     158826.3     158826.3   -538.40178   -538.40178 
   99000   -36227.551   -36227.551   -36532.543   -36532.543    294.97685    294.97685     158507.1     158507.1    926.96986    926.96986 
Loop time of 284.033 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.898 hours/ns, 3.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.64     | 282.64     | 282.64     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11862    | 0.11862    | 0.11862    |   0.0 |  0.04
Output  | 0.00020474 | 0.00020474 | 0.00020474 |   0.0 |  0.00
Modify  | 1.1522     | 1.1522     | 1.1522     |   0.0 |  0.41
Other   |            | 0.124      |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      384424.0 ave      384424 max      384424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 384424
Ave neighs/atom = 48.053000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.886270065855, Press = -0.307541835891604
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -36227.551   -36227.551   -36532.543   -36532.543    294.97685    294.97685     158507.1     158507.1    926.96986    926.96986 
  100000   -36229.656   -36229.656   -36533.715   -36533.715    294.07456    294.07456    158577.73    158577.73    876.36078    876.36078 
Loop time of 284.14 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.928 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.74     | 282.74     | 282.74     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11888    | 0.11888    | 0.11888    |   0.0 |  0.04
Output  | 0.00018902 | 0.00018902 | 0.00018902 |   0.0 |  0.00
Modify  | 1.1523     | 1.1523     | 1.1523     |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386474.0 ave      386474 max      386474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386474
Ave neighs/atom = 48.309250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.884557724908, Press = 0.146124607730359
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -36229.656   -36229.656   -36533.715   -36533.715    294.07456    294.07456    158577.73    158577.73    876.36078    876.36078 
  101000   -36224.659   -36224.659   -36531.196   -36531.196    296.47192    296.47192    158676.77    158676.77   -108.45974   -108.45974 
Loop time of 283.893 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.859 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.5      | 282.5      | 282.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11747    | 0.11747    | 0.11747    |   0.0 |  0.04
Output  | 0.00021324 | 0.00021324 | 0.00021324 |   0.0 |  0.00
Modify  | 1.1486     | 1.1486     | 1.1486     |   0.0 |  0.40
Other   |            | 0.1237     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6727.00 ave        6727 max        6727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385484.0 ave      385484 max      385484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385484
Ave neighs/atom = 48.185500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.898451644993, Press = -0.116234981337192
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -36224.659   -36224.659   -36531.196   -36531.196    296.47192    296.47192    158676.77    158676.77   -108.45974   -108.45974 
  102000   -36228.976   -36228.976   -36530.998   -36530.998    292.10412    292.10412    158685.96    158685.96    84.505703    84.505703 
Loop time of 284.027 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.896 hours/ns, 3.521 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.64     | 282.64     | 282.64     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11766    | 0.11766    | 0.11766    |   0.0 |  0.04
Output  | 0.00020179 | 0.00020179 | 0.00020179 |   0.0 |  0.00
Modify  | 1.1489     | 1.1489     | 1.1489     |   0.0 |  0.40
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386310.0 ave      386310 max      386310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386310
Ave neighs/atom = 48.288750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.888303728199, Press = -0.292450453993162
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -36228.976   -36228.976   -36530.998   -36530.998    292.10412    292.10412    158685.96    158685.96    84.505703    84.505703 
  103000   -36228.564   -36228.564   -36530.131   -36530.131    291.66456    291.66456    158500.61    158500.61    1093.5717    1093.5717 
Loop time of 284.171 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.936 hours/ns, 3.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.78     | 282.78     | 282.78     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11782    | 0.11782    | 0.11782    |   0.0 |  0.04
Output  | 0.00019883 | 0.00019883 | 0.00019883 |   0.0 |  0.00
Modify  | 1.1498     | 1.1498     | 1.1498     |   0.0 |  0.40
Other   |            | 0.1237     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385208.0 ave      385208 max      385208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385208
Ave neighs/atom = 48.151000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.891017278328, Press = -0.0474247201227709
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -36228.564   -36228.564   -36530.131   -36530.131    291.66456    291.66456    158500.61    158500.61    1093.5717    1093.5717 
  104000    -36226.73    -36226.73   -36530.691   -36530.691    293.98036    293.98036    158695.71    158695.71     130.6437     130.6437 
Loop time of 283.792 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.831 hours/ns, 3.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.4      | 282.4      | 282.4      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11814    | 0.11814    | 0.11814    |   0.0 |  0.04
Output  | 0.00020095 | 0.00020095 | 0.00020095 |   0.0 |  0.00
Modify  | 1.1501     | 1.1501     | 1.1501     |   0.0 |  0.41
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386390.0 ave      386390 max      386390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386390
Ave neighs/atom = 48.298750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.882037963303, Press = -0.0648267078167783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000    -36226.73    -36226.73   -36530.691   -36530.691    293.98036    293.98036    158695.71    158695.71     130.6437     130.6437 
  105000   -36230.244   -36230.244   -36532.586   -36532.586    292.41375    292.41375    158783.93    158783.93   -415.64513   -415.64513 
Loop time of 284.062 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.906 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.67     | 282.67     | 282.67     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11859    | 0.11859    | 0.11859    |   0.0 |  0.04
Output  | 0.00020575 | 0.00020575 | 0.00020575 |   0.0 |  0.00
Modify  | 1.1514     | 1.1514     | 1.1514     |   0.0 |  0.41
Other   |            | 0.1236     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385660.0 ave      385660 max      385660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385660
Ave neighs/atom = 48.207500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.887765870721, Press = -0.0428171018496932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -36230.244   -36230.244   -36532.586   -36532.586    292.41375    292.41375    158783.93    158783.93   -415.64513   -415.64513 
  106000   -36219.151   -36219.151   -36524.747   -36524.747    295.56175    295.56175    158561.81    158561.81    518.94536    518.94536 
Loop time of 284.071 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.909 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.68     | 282.68     | 282.68     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11845    | 0.11845    | 0.11845    |   0.0 |  0.04
Output  | 0.00020155 | 0.00020155 | 0.00020155 |   0.0 |  0.00
Modify  | 1.1524     | 1.1524     | 1.1524     |   0.0 |  0.41
Other   |            | 0.124      |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385286.0 ave      385286 max      385286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385286
Ave neighs/atom = 48.160750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.900735592454, Press = -0.0165768062277996
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000   -36219.151   -36219.151   -36524.747   -36524.747    295.56175    295.56175    158561.81    158561.81    518.94536    518.94536 
  107000   -36228.265   -36228.265   -36534.608   -36534.608    296.28399    296.28399    158682.15    158682.15      140.001      140.001 
Loop time of 284.084 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.912 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.69     | 282.69     | 282.69     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11878    | 0.11878    | 0.11878    |   0.0 |  0.04
Output  | 0.00021211 | 0.00021211 | 0.00021211 |   0.0 |  0.00
Modify  | 1.1524     | 1.1524     | 1.1524     |   0.0 |  0.41
Other   |            | 0.1241     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6729.00 ave        6729 max        6729 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      386634.0 ave      386634 max      386634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 386634
Ave neighs/atom = 48.329250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.914439429589, Press = 0.146720308482932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -36228.265   -36228.265   -36534.608   -36534.608    296.28399    296.28399    158682.15    158682.15      140.001      140.001 
  108000   -36229.879   -36229.879   -36533.034   -36533.034    293.19978    293.19978    158775.55    158775.55   -238.14261   -238.14261 
Loop time of 283.9 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.861 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.51     | 282.51     | 282.51     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1187     | 0.1187     | 0.1187     |   0.0 |  0.04
Output  | 0.00019083 | 0.00019083 | 0.00019083 |   0.0 |  0.00
Modify  | 1.152      | 1.152      | 1.152      |   0.0 |  0.41
Other   |            | 0.1239     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385564.0 ave      385564 max      385564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385564
Ave neighs/atom = 48.195500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.91474374854, Press = -0.0970026872995217
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -36229.879   -36229.879   -36533.034   -36533.034    293.19978    293.19978    158775.55    158775.55   -238.14261   -238.14261 
  109000   -36224.411   -36224.411   -36531.275   -36531.275    296.78686    296.78686    158754.46    158754.46   -151.62973   -151.62973 
Loop time of 283.884 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.857 hours/ns, 3.523 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.49     | 282.49     | 282.49     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11737    | 0.11737    | 0.11737    |   0.0 |  0.04
Output  | 0.00021188 | 0.00021188 | 0.00021188 |   0.0 |  0.00
Modify  | 1.1487     | 1.1487     | 1.1487     |   0.0 |  0.40
Other   |            | 0.1233     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385056.0 ave      385056 max      385056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385056
Ave neighs/atom = 48.132000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.922827654865, Press = -0.0597481958275019
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -36224.411   -36224.411   -36531.275   -36531.275    296.78686    296.78686    158754.46    158754.46   -151.62973   -151.62973 
  110000    -36230.25    -36230.25   -36534.878   -36534.878    294.62497    294.62497    158594.26    158594.26    528.80279    528.80279 
Loop time of 283.954 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.876 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.56     | 282.56     | 282.56     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11848    | 0.11848    | 0.11848    |   0.0 |  0.04
Output  | 0.00019887 | 0.00019887 | 0.00019887 |   0.0 |  0.00
Modify  | 1.1489     | 1.1489     | 1.1489     |   0.0 |  0.40
Other   |            | 0.1235     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385152.0 ave      385152 max      385152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385152
Ave neighs/atom = 48.144000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.92419072918, Press = -0.0982207362238593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000    -36230.25    -36230.25   -36534.878   -36534.878    294.62497    294.62497    158594.26    158594.26    528.80279    528.80279 
  111000   -36220.067   -36220.067   -36531.096   -36531.096    300.81572    300.81572    158674.42    158674.42    127.89526    127.89526 
Loop time of 284.13 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.925 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.74     | 282.74     | 282.74     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11783    | 0.11783    | 0.11783    |   0.0 |  0.04
Output  | 0.0001997  | 0.0001997  | 0.0001997  |   0.0 |  0.00
Modify  | 1.1496     | 1.1496     | 1.1496     |   0.0 |  0.40
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6726.00 ave        6726 max        6726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385872.0 ave      385872 max      385872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385872
Ave neighs/atom = 48.234000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.932500803493, Press = 0.0437763060794202
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -36220.067   -36220.067   -36531.096   -36531.096    300.81572    300.81572    158674.42    158674.42    127.89526    127.89526 
  112000   -36229.776   -36229.776   -36530.705   -36530.705     291.0474     291.0474    158740.22    158740.22   -39.156764   -39.156764 
Loop time of 283.937 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.871 hours/ns, 3.522 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.54     | 282.54     | 282.54     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11836    | 0.11836    | 0.11836    |   0.0 |  0.04
Output  | 0.00020309 | 0.00020309 | 0.00020309 |   0.0 |  0.00
Modify  | 1.1505     | 1.1505     | 1.1505     |   0.0 |  0.41
Other   |            | 0.124      |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385576.0 ave      385576 max      385576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385576
Ave neighs/atom = 48.197000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.945298844481, Press = -0.0395714333256429
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 17 17 17
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.679 | 4.679 | 4.679 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -36229.776   -36229.776   -36530.705   -36530.705     291.0474     291.0474    158740.22    158740.22   -39.156764   -39.156764 
  113000   -36221.463   -36221.463   -36524.245   -36524.245    292.83924    292.83924    158647.29    158647.29    -29.59083    -29.59083 
Loop time of 284.105 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.304 ns/day, 78.918 hours/ns, 3.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 282.71     | 282.71     | 282.71     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11864    | 0.11864    | 0.11864    |   0.0 |  0.04
Output  | 0.0002056  | 0.0002056  | 0.0002056  |   0.0 |  0.00
Modify  | 1.1512     | 1.1512     | 1.1512     |   0.0 |  0.41
Other   |            | 0.1238     |            |       |  0.04

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6725.00 ave        6725 max        6725 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      385128.0 ave      385128 max      385128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 385128
Ave neighs/atom = 48.141000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
158693.848438479

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0