# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.917371600866318*${_u_distance}
variable latticeconst_converted equal 3.917371600866318*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.91737160086632
Lattice spacing in x,y,z = 3.9173716 3.9173716 3.9173716
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 (39.173716 39.173716 39.173716)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (39.173716 39.173716 39.173716)
  create_atoms CPU = 0.006 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtCu__MO_070797404269_001
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 60115.2021282468 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_070797404269_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 = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -22918.129   -22918.129       -23080       -23080       313.15       313.15    60115.202    60115.202      2876.04      2876.04 
    1000   -22752.866   -22752.866   -22913.444   -22913.444    310.64881    310.64881    60733.703    60733.703    596.91704    596.91704 
Loop time of 190.007 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.780 hours/ns, 5.263 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 189.04     | 189.04     | 189.04     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16304    | 0.16304    | 0.16304    |   0.0 |  0.09
Output  | 0.0002703  | 0.0002703  | 0.0002703  |   0.0 |  0.00
Modify  | 0.70766    | 0.70766    | 0.70766    |   0.0 |  0.37
Other   |            | 0.09883    |            |       |  0.05

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

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

Performance: 0.438 ns/day, 54.816 hours/ns, 5.067 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    | 196.4      | 196.4      | 196.4      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15513    | 0.15513    | 0.15513    |   0.0 |  0.08
Output  | 0.00021503 | 0.00021503 | 0.00021503 |   0.0 |  0.00
Modify  | 0.68318    | 0.68318    | 0.68318    |   0.0 |  0.35
Other   |            | 0.09701    |            |       |  0.05

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

Total # of neighbors = 311874
Ave neighs/atom = 77.968500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -22759.371   -22759.371   -22915.368   -22915.368     301.7871     301.7871    60706.675    60706.675    966.60623    966.60623 
    3000   -22759.961   -22759.961   -22919.611   -22919.611    308.85379    308.85379    60724.979    60724.979    137.29695    137.29695 
Loop time of 200.202 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.612 hours/ns, 4.995 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    | 199.25     | 199.25     | 199.25     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15616    | 0.15616    | 0.15616    |   0.0 |  0.08
Output  | 0.00021049 | 0.00021049 | 0.00021049 |   0.0 |  0.00
Modify  | 0.69388    | 0.69388    | 0.69388    |   0.0 |  0.35
Other   |            | 0.09784    |            |       |  0.05

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

Total # of neighbors = 311890
Ave neighs/atom = 77.972500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -22759.961   -22759.961   -22919.611   -22919.611    308.85379    308.85379    60724.979    60724.979    137.29695    137.29695 
    4000   -22755.636   -22755.636   -22923.466   -22923.466    324.67794    324.67794    60715.315    60715.315    123.58187    123.58187 
Loop time of 197.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 54.991 hours/ns, 5.051 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.02     | 197.02     | 197.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15576    | 0.15576    | 0.15576    |   0.0 |  0.08
Output  | 0.00021348 | 0.00021348 | 0.00021348 |   0.0 |  0.00
Modify  | 0.69223    | 0.69223    | 0.69223    |   0.0 |  0.35
Other   |            | 0.09876    |            |       |  0.05

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

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

Performance: 0.433 ns/day, 55.374 hours/ns, 5.016 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    | 198.4      | 198.4      | 198.4      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15569    | 0.15569    | 0.15569    |   0.0 |  0.08
Output  | 0.00017862 | 0.00017862 | 0.00017862 |   0.0 |  0.00
Modify  | 0.69744    | 0.69744    | 0.69744    |   0.0 |  0.35
Other   |            | 0.09886    |            |       |  0.05

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

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

Performance: 0.437 ns/day, 54.965 hours/ns, 5.054 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    | 196.92     | 196.92     | 196.92     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15368    | 0.15368    | 0.15368    |   0.0 |  0.08
Output  | 0.00017706 | 0.00017706 | 0.00017706 |   0.0 |  0.00
Modify  | 0.70689    | 0.70689    | 0.70689    |   0.0 |  0.36
Other   |            | 0.09717    |            |       |  0.05

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

Total # of neighbors = 311918
Ave neighs/atom = 77.979500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.524047275886, Press = -29.6246843097061
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -22753.907   -22753.907   -22920.113   -22920.113    321.53736    321.53736    60786.914    60786.914   -1698.3478   -1698.3478 
    7000   -22762.186   -22762.186   -22921.339   -22921.339    307.89196    307.89196    60796.491    60796.491   -2202.2757   -2202.2757 
Loop time of 195.007 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.169 hours/ns, 5.128 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.07     | 194.07     | 194.07     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15338    | 0.15338    | 0.15338    |   0.0 |  0.08
Output  | 0.0001824  | 0.0001824  | 0.0001824  |   0.0 |  0.00
Modify  | 0.69065    | 0.69065    | 0.69065    |   0.0 |  0.35
Other   |            | 0.09652    |            |       |  0.05

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

Total # of neighbors = 311920
Ave neighs/atom = 77.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.723085770184, Press = 2.51931435316124
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -22762.186   -22762.186   -22921.339   -22921.339    307.89196    307.89196    60796.491    60796.491   -2202.2757   -2202.2757 
    8000   -22761.484   -22761.484   -22920.892   -22920.892    308.38628    308.38628    60747.971    60747.971    -762.7059    -762.7059 
Loop time of 195.516 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.310 hours/ns, 5.115 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.56     | 194.56     | 194.56     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15591    | 0.15591    | 0.15591    |   0.0 |  0.08
Output  | 0.00017528 | 0.00017528 | 0.00017528 |   0.0 |  0.00
Modify  | 0.70026    | 0.70026    | 0.70026    |   0.0 |  0.36
Other   |            | 0.09726    |            |       |  0.05

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

Total # of neighbors = 311868
Ave neighs/atom = 77.967000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.906770094878, Press = 8.31654372879048
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -22761.484   -22761.484   -22920.892   -22920.892    308.38628    308.38628    60747.971    60747.971    -762.7059    -762.7059 
    9000   -22751.859   -22751.859   -22919.095   -22919.095     323.5286     323.5286    60712.115    60712.115    606.81587    606.81587 
Loop time of 195.54 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.317 hours/ns, 5.114 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.59     | 194.59     | 194.59     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15297    | 0.15297    | 0.15297    |   0.0 |  0.08
Output  | 0.0001775  | 0.0001775  | 0.0001775  |   0.0 |  0.00
Modify  | 0.69907    | 0.69907    | 0.69907    |   0.0 |  0.36
Other   |            | 0.09691    |            |       |  0.05

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

Total # of neighbors = 311902
Ave neighs/atom = 77.975500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.208064209858, Press = 2.80790524584162
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -22751.859   -22751.859   -22919.095   -22919.095     323.5286     323.5286    60712.115    60712.115    606.81587    606.81587 
   10000   -22759.486   -22759.486   -22922.794   -22922.794    315.93105    315.93105    60692.477    60692.477    797.66176    797.66176 
Loop time of 197.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.860 hours/ns, 5.063 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    | 196.54     | 196.54     | 196.54     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15446    | 0.15446    | 0.15446    |   0.0 |  0.08
Output  | 0.00017716 | 0.00017716 | 0.00017716 |   0.0 |  0.00
Modify  | 0.70388    | 0.70388    | 0.70388    |   0.0 |  0.36
Other   |            | 0.09792    |            |       |  0.05

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

Total # of neighbors = 311894
Ave neighs/atom = 77.973500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.45873307171, Press = -3.76855802882167
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -22759.486   -22759.486   -22922.794   -22922.794    315.93105    315.93105    60692.477    60692.477    797.66176    797.66176 
   11000   -22755.404   -22755.404    -22917.79    -22917.79    314.14763    314.14763    60714.644    60714.644    510.98143    510.98143 
Loop time of 198.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.070 hours/ns, 5.044 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.29     | 197.29     | 197.29     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15507    | 0.15507    | 0.15507    |   0.0 |  0.08
Output  | 0.00025387 | 0.00025387 | 0.00025387 |   0.0 |  0.00
Modify  | 0.71117    | 0.71117    | 0.71117    |   0.0 |  0.36
Other   |            | 0.09763    |            |       |  0.05

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

Total # of neighbors = 311892
Ave neighs/atom = 77.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.735154534208, Press = -4.99301713267029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -22755.404   -22755.404    -22917.79    -22917.79    314.14763    314.14763    60714.644    60714.644    510.98143    510.98143 
   12000   -22760.641   -22760.641   -22922.257   -22922.257    312.65642    312.65642    60735.017    60735.017   -474.77052   -474.77052 
Loop time of 196.693 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.637 hours/ns, 5.084 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    | 195.74     | 195.74     | 195.74     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15478    | 0.15478    | 0.15478    |   0.0 |  0.08
Output  | 0.00017861 | 0.00017861 | 0.00017861 |   0.0 |  0.00
Modify  | 0.70315    | 0.70315    | 0.70315    |   0.0 |  0.36
Other   |            | 0.09681    |            |       |  0.05

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

Total # of neighbors = 311872
Ave neighs/atom = 77.968000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.730570769284, Press = -5.08458038487028
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -22760.641   -22760.641   -22922.257   -22922.257    312.65642    312.65642    60735.017    60735.017   -474.77052   -474.77052 
   13000   -22758.557   -22758.557   -22923.647   -22923.647    319.37834    319.37834    60781.354    60781.354   -1808.9941   -1808.9941 
Loop time of 197.577 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.883 hours/ns, 5.061 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    | 196.62     | 196.62     | 196.62     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15319    | 0.15319    | 0.15319    |   0.0 |  0.08
Output  | 0.00018075 | 0.00018075 | 0.00018075 |   0.0 |  0.00
Modify  | 0.70625    | 0.70625    | 0.70625    |   0.0 |  0.36
Other   |            | 0.09748    |            |       |  0.05

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

Total # of neighbors = 311926
Ave neighs/atom = 77.981500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.926174541195, Press = -5.16601835480366
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -22758.557   -22758.557   -22923.647   -22923.647    319.37834    319.37834    60781.354    60781.354   -1808.9941   -1808.9941 
   14000   -22753.226   -22753.226   -22913.803   -22913.803    310.64634    310.64634    60817.355    60817.355   -2096.6487   -2096.6487 
Loop time of 198.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.277 hours/ns, 5.025 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    | 198.02     | 198.02     | 198.02     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15675    | 0.15675    | 0.15675    |   0.0 |  0.08
Output  | 0.00018023 | 0.00018023 | 0.00018023 |   0.0 |  0.00
Modify  | 0.71735    | 0.71735    | 0.71735    |   0.0 |  0.36
Other   |            | 0.09819    |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.953027349263, Press = 2.62427217314897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -22753.226   -22753.226   -22913.803   -22913.803    310.64634    310.64634    60817.355    60817.355   -2096.6487   -2096.6487 
   15000   -22759.088   -22759.088   -22922.309   -22922.309     315.7625     315.7625    60720.989    60720.989    93.839548    93.839548 
Loop time of 197.144 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.762 hours/ns, 5.072 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    | 196.19     | 196.19     | 196.19     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15475    | 0.15475    | 0.15475    |   0.0 |  0.08
Output  | 0.00049375 | 0.00049375 | 0.00049375 |   0.0 |  0.00
Modify  | 0.70454    | 0.70454    | 0.70454    |   0.0 |  0.36
Other   |            | 0.09784    |            |       |  0.05

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

Total # of neighbors = 311860
Ave neighs/atom = 77.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.040986649081, Press = 2.62633691185147
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -22759.088   -22759.088   -22922.309   -22922.309     315.7625     315.7625    60720.989    60720.989    93.839548    93.839548 
   16000   -22757.615   -22757.615   -22917.324   -22917.324    308.96862    308.96862    60705.722    60705.722     854.9542     854.9542 
Loop time of 196.734 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.648 hours/ns, 5.083 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    | 195.79     | 195.79     | 195.79     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15205    | 0.15205    | 0.15205    |   0.0 |  0.08
Output  | 0.00017852 | 0.00017852 | 0.00017852 |   0.0 |  0.00
Modify  | 0.69727    | 0.69727    | 0.69727    |   0.0 |  0.35
Other   |            | 0.09654    |            |       |  0.05

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

Total # of neighbors = 311918
Ave neighs/atom = 77.979500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.992880762141, Press = 0.264218745632497
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -22757.615   -22757.615   -22917.324   -22917.324    308.96862    308.96862    60705.722    60705.722     854.9542     854.9542 
   17000   -22753.421   -22753.421   -22918.206   -22918.206    318.78608    318.78608    60705.833    60705.833    948.90274    948.90274 
Loop time of 196.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.703 hours/ns, 5.078 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    | 195.98     | 195.98     | 195.98     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15409    | 0.15409    | 0.15409    |   0.0 |  0.08
Output  | 0.00018005 | 0.00018005 | 0.00018005 |   0.0 |  0.00
Modify  | 0.70152    | 0.70152    | 0.70152    |   0.0 |  0.36
Other   |            | 0.09699    |            |       |  0.05

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

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.999811545229, Press = -0.773356706396322
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -22753.421   -22753.421   -22918.206   -22918.206    318.78608    318.78608    60705.833    60705.833    948.90274    948.90274 
   18000   -22760.109   -22760.109   -22921.439   -22921.439    312.10309    312.10309    60709.437    60709.437    362.32537    362.32537 
Loop time of 197.52 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.867 hours/ns, 5.063 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    | 196.56     | 196.56     | 196.56     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15465    | 0.15465    | 0.15465    |   0.0 |  0.08
Output  | 0.0001746  | 0.0001746  | 0.0001746  |   0.0 |  0.00
Modify  | 0.71068    | 0.71068    | 0.71068    |   0.0 |  0.36
Other   |            | 0.09793    |            |       |  0.05

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

Total # of neighbors = 311920
Ave neighs/atom = 77.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.092806348556, Press = -2.83617995455695
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -22760.109   -22760.109   -22921.439   -22921.439    312.10309    312.10309    60709.437    60709.437    362.32537    362.32537 
   19000   -22762.042   -22762.042   -22921.637   -22921.637    308.74656    308.74656    60750.994    60750.994   -879.49213   -879.49213 
Loop time of 199.681 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.467 hours/ns, 5.008 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    | 198.71     | 198.71     | 198.71     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15547    | 0.15547    | 0.15547    |   0.0 |  0.08
Output  | 0.00022188 | 0.00022188 | 0.00022188 |   0.0 |  0.00
Modify  | 0.7139     | 0.7139     | 0.7139     |   0.0 |  0.36
Other   |            | 0.09854    |            |       |  0.05

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

Total # of neighbors = 311922
Ave neighs/atom = 77.980500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.08541445324, Press = -3.72560358288901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -22762.042   -22762.042   -22921.637   -22921.637    308.74656    308.74656    60750.994    60750.994   -879.49213   -879.49213 
   20000   -22757.631   -22757.631   -22920.641   -22920.641    315.35376    315.35376    60802.438    60802.438   -2269.8611   -2269.8611 
Loop time of 198.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.118 hours/ns, 5.040 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.46     | 197.46     | 197.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15564    | 0.15564    | 0.15564    |   0.0 |  0.08
Output  | 0.00017846 | 0.00017846 | 0.00017846 |   0.0 |  0.00
Modify  | 0.71406    | 0.71406    | 0.71406    |   0.0 |  0.36
Other   |            | 0.09789    |            |       |  0.05

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

Total # of neighbors = 311910
Ave neighs/atom = 77.977500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.897481365906, Press = -1.45178013053075
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -22757.631   -22757.631   -22920.641   -22920.641    315.35376    315.35376    60802.438    60802.438   -2269.8611   -2269.8611 
   21000   -22765.088   -22765.088   -22924.093   -22924.093    307.60448    307.60448    60750.648    60750.648   -1040.8611   -1040.8611 
Loop time of 194.81 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.114 hours/ns, 5.133 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    | 193.87     | 193.87     | 193.87     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15322    | 0.15322    | 0.15322    |   0.0 |  0.08
Output  | 0.00017876 | 0.00017876 | 0.00017876 |   0.0 |  0.00
Modify  | 0.69392    | 0.69392    | 0.69392    |   0.0 |  0.36
Other   |            | 0.09688    |            |       |  0.05

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

Total # of neighbors = 311860
Ave neighs/atom = 77.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.782305875505, Press = 0.365845920811835
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -22765.088   -22765.088   -22924.093   -22924.093    307.60448    307.60448    60750.648    60750.648   -1040.8611   -1040.8611 
   22000   -22760.137   -22760.137   -22920.309   -22920.309    309.86361    309.86361    60701.193    60701.193    734.81963    734.81963 
Loop time of 197.605 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.890 hours/ns, 5.061 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    | 196.64     | 196.64     | 196.64     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15498    | 0.15498    | 0.15498    |   0.0 |  0.08
Output  | 0.00017665 | 0.00017665 | 0.00017665 |   0.0 |  0.00
Modify  | 0.71497    | 0.71497    | 0.71497    |   0.0 |  0.36
Other   |            | 0.09798    |            |       |  0.05

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

Total # of neighbors = 311888
Ave neighs/atom = 77.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.69457758503, Press = 0.349988317681347
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -22760.137   -22760.137   -22920.309   -22920.309    309.86361    309.86361    60701.193    60701.193    734.81963    734.81963 
   23000   -22749.901   -22749.901   -22918.149   -22918.149    325.48662    325.48662    60726.659    60726.659    326.18716    326.18716 
Loop time of 198.416 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.116 hours/ns, 5.040 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.45     | 197.45     | 197.45     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15565    | 0.15565    | 0.15565    |   0.0 |  0.08
Output  | 0.00017282 | 0.00017282 | 0.00017282 |   0.0 |  0.00
Modify  | 0.70953    | 0.70953    | 0.70953    |   0.0 |  0.36
Other   |            | 0.09681    |            |       |  0.05

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

Total # of neighbors = 311920
Ave neighs/atom = 77.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.718791859394, Press = -0.816363391918052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -22749.901   -22749.901   -22918.149   -22918.149    325.48662    325.48662    60726.659    60726.659    326.18716    326.18716 
   24000   -22760.944   -22760.944   -22923.341   -22923.341    314.16705    314.16705     60728.54     60728.54   -335.23372   -335.23372 
Loop time of 198.265 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.074 hours/ns, 5.044 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.3      | 197.3      | 197.3      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15601    | 0.15601    | 0.15601    |   0.0 |  0.08
Output  | 0.00017629 | 0.00017629 | 0.00017629 |   0.0 |  0.00
Modify  | 0.71286    | 0.71286    | 0.71286    |   0.0 |  0.36
Other   |            | 0.09849    |            |       |  0.05

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

Total # of neighbors = 311892
Ave neighs/atom = 77.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.77411682653, Press = -1.12251240363146
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -22760.944   -22760.944   -22923.341   -22923.341    314.16705    314.16705     60728.54     60728.54   -335.23372   -335.23372 
   25000   -22753.773   -22753.773   -22917.443   -22917.443    316.62987    316.62987    60724.213    60724.213    312.57632    312.57632 
Loop time of 198.097 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.027 hours/ns, 5.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.14     | 197.14     | 197.14     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15484    | 0.15484    | 0.15484    |   0.0 |  0.08
Output  | 0.0001758  | 0.0001758  | 0.0001758  |   0.0 |  0.00
Modify  | 0.70766    | 0.70766    | 0.70766    |   0.0 |  0.36
Other   |            | 0.09647    |            |       |  0.05

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

Total # of neighbors = 311906
Ave neighs/atom = 77.976500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.830991823329, Press = -0.795010259251158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -22753.773   -22753.773   -22917.443   -22917.443    316.62987    316.62987    60724.213    60724.213    312.57632    312.57632 
   26000   -22756.786   -22756.786   -22917.786   -22917.786    311.46474    311.46474    60717.609    60717.609    394.18984    394.18984 
Loop time of 199.947 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.541 hours/ns, 5.001 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    | 198.97     | 198.97     | 198.97     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15666    | 0.15666    | 0.15666    |   0.0 |  0.08
Output  | 0.00022312 | 0.00022312 | 0.00022312 |   0.0 |  0.00
Modify  | 0.71864    | 0.71864    | 0.71864    |   0.0 |  0.36
Other   |            | 0.09785    |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.811500886589, Press = -1.18536840010743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -22756.786   -22756.786   -22917.786   -22917.786    311.46474    311.46474    60717.609    60717.609    394.18984    394.18984 
   27000   -22764.223   -22764.223   -22926.282   -22926.282    313.51423    313.51423    60729.986    60729.986   -659.38963   -659.38963 
Loop time of 197.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.809 hours/ns, 5.068 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    | 196.35     | 196.35     | 196.35     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15485    | 0.15485    | 0.15485    |   0.0 |  0.08
Output  | 0.000177   | 0.000177   | 0.000177   |   0.0 |  0.00
Modify  | 0.70888    | 0.70888    | 0.70888    |   0.0 |  0.36
Other   |            | 0.09742    |            |       |  0.05

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

Total # of neighbors = 311896
Ave neighs/atom = 77.974000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.717975546534, Press = -1.71990934787166
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -22764.223   -22764.223   -22926.282   -22926.282    313.51423    313.51423    60729.986    60729.986   -659.38963   -659.38963 
   28000   -22758.862   -22758.862   -22922.448   -22922.448    316.46961    316.46961    60788.868    60788.868   -2079.6491   -2079.6491 
Loop time of 198.802 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.223 hours/ns, 5.030 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.83     | 197.83     | 197.83     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15454    | 0.15454    | 0.15454    |   0.0 |  0.08
Output  | 0.00022837 | 0.00022837 | 0.00022837 |   0.0 |  0.00
Modify  | 0.71792    | 0.71792    | 0.71792    |   0.0 |  0.36
Other   |            | 0.09739    |            |       |  0.05

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

Total # of neighbors = 311904
Ave neighs/atom = 77.976000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.644617877767, Press = -1.22627497127609
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -22758.862   -22758.862   -22922.448   -22922.448    316.46961    316.46961    60788.868    60788.868   -2079.6491   -2079.6491 
   29000   -22754.561   -22754.561   -22918.647   -22918.647    317.43503    317.43503     60760.46     60760.46   -823.61573   -823.61573 
Loop time of 201.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.839 hours/ns, 4.975 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.05     | 200.05     | 200.05     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15695    | 0.15695    | 0.15695    |   0.0 |  0.08
Output  | 0.00024918 | 0.00024918 | 0.00024918 |   0.0 |  0.00
Modify  | 0.71862    | 0.71862    | 0.71862    |   0.0 |  0.36
Other   |            | 0.09837    |            |       |  0.05

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

Total # of neighbors = 311900
Ave neighs/atom = 77.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.598307632993, Press = 0.750302790824639
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -22754.561   -22754.561   -22918.647   -22918.647    317.43503    317.43503     60760.46     60760.46   -823.61573   -823.61573 
   30000   -22761.017   -22761.017   -22923.708   -22923.708    314.73633    314.73633    60680.819    60680.819     1029.649     1029.649 
Loop time of 201.891 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.081 hours/ns, 4.953 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.9      | 200.9      | 200.9      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15827    | 0.15827    | 0.15827    |   0.0 |  0.08
Output  | 0.00029245 | 0.00029245 | 0.00029245 |   0.0 |  0.00
Modify  | 0.72992    | 0.72992    | 0.72992    |   0.0 |  0.36
Other   |            | 0.09952    |            |       |  0.05

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

Total # of neighbors = 311886
Ave neighs/atom = 77.971500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.634293027107, Press = 1.05590213261896
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -22761.017   -22761.017   -22923.708   -22923.708    314.73633    314.73633    60680.819    60680.819     1029.649     1029.649 
   31000   -22754.577   -22754.577   -22916.543   -22916.543    313.33488    313.33488    60680.373    60680.373    1665.6726    1665.6726 
Loop time of 197.564 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.879 hours/ns, 5.062 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    | 196.6      | 196.6      | 196.6      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15502    | 0.15502    | 0.15502    |   0.0 |  0.08
Output  | 0.00017755 | 0.00017755 | 0.00017755 |   0.0 |  0.00
Modify  | 0.70705    | 0.70705    | 0.70705    |   0.0 |  0.36
Other   |            | 0.09955    |            |       |  0.05

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

Total # of neighbors = 311920
Ave neighs/atom = 77.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.669088923457, Press = -0.69363650157398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -22754.577   -22754.577   -22916.543   -22916.543    313.33488    313.33488    60680.373    60680.373    1665.6726    1665.6726 
   32000   -22761.888   -22761.888   -22920.618   -22920.618    307.07289    307.07289    60709.297    60709.297    428.04034    428.04034 
Loop time of 195.41 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.281 hours/ns, 5.117 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.46     | 194.46     | 194.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15393    | 0.15393    | 0.15393    |   0.0 |  0.08
Output  | 0.00017863 | 0.00017863 | 0.00017863 |   0.0 |  0.00
Modify  | 0.69854    | 0.69854    | 0.69854    |   0.0 |  0.36
Other   |            | 0.09793    |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.703380608618, Press = -1.23351241121302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -22761.888   -22761.888   -22920.618   -22920.618    307.07289    307.07289    60709.297    60709.297    428.04034    428.04034 
   33000   -22755.818   -22755.818   -22920.033   -22920.033    317.68435    317.68435    60745.743    60745.743   -553.44012   -553.44012 
Loop time of 196.956 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.710 hours/ns, 5.077 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    | 196        | 196        | 196        |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15348    | 0.15348    | 0.15348    |   0.0 |  0.08
Output  | 0.00018021 | 0.00018021 | 0.00018021 |   0.0 |  0.00
Modify  | 0.70143    | 0.70143    | 0.70143    |   0.0 |  0.36
Other   |            | 0.097      |            |       |  0.05

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

Total # of neighbors = 311890
Ave neighs/atom = 77.972500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.687872249139, Press = -1.24528653742253
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -22755.818   -22755.818   -22920.033   -22920.033    317.68435    317.68435    60745.743    60745.743   -553.44012   -553.44012 
   34000   -22759.416   -22759.416   -22923.163   -22923.163    316.77872    316.77872    60756.243    60756.243   -999.29065   -999.29065 
Loop time of 194.333 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.981 hours/ns, 5.146 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.4      | 193.4      | 193.4      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15178    | 0.15178    | 0.15178    |   0.0 |  0.08
Output  | 0.00017772 | 0.00017772 | 0.00017772 |   0.0 |  0.00
Modify  | 0.68866    | 0.68866    | 0.68866    |   0.0 |  0.35
Other   |            | 0.09598    |            |       |  0.05

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

Total # of neighbors = 311898
Ave neighs/atom = 77.974500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.685778740116, Press = -0.671093477525159
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -22759.416   -22759.416   -22923.163   -22923.163    316.77872    316.77872    60756.243    60756.243   -999.29065   -999.29065 
   35000   -22758.112   -22758.112    -22920.08    -22920.08    313.33839    313.33839    60778.224    60778.224   -1406.0498   -1406.0498 
Loop time of 197.628 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.897 hours/ns, 5.060 timesteps/s
100.0% 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.67     | 196.67     | 196.67     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15444    | 0.15444    | 0.15444    |   0.0 |  0.08
Output  | 0.00017858 | 0.00017858 | 0.00017858 |   0.0 |  0.00
Modify  | 0.70685    | 0.70685    | 0.70685    |   0.0 |  0.36
Other   |            | 0.09765    |            |       |  0.05

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

Total # of neighbors = 311902
Ave neighs/atom = 77.975500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.738494190294, Press = 1.57284383705643
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -22758.112   -22758.112    -22920.08    -22920.08    313.33839    313.33839    60778.224    60778.224   -1406.0498   -1406.0498 
   36000    -22756.51    -22756.51   -22919.633   -22919.633    315.57132    315.57132    60681.656    60681.656    1440.7337    1440.7337 
Loop time of 196.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.656 hours/ns, 5.082 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    | 195.81     | 195.81     | 195.81     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15235    | 0.15235    | 0.15235    |   0.0 |  0.08
Output  | 0.00017771 | 0.00017771 | 0.00017771 |   0.0 |  0.00
Modify  | 0.70121    | 0.70121    | 0.70121    |   0.0 |  0.36
Other   |            | 0.09695    |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.746205703378, Press = 1.23972728254562
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -22756.51    -22756.51   -22919.633   -22919.633    315.57132    315.57132    60681.656    60681.656    1440.7337    1440.7337 
   37000   -22762.847   -22762.847   -22920.961   -22920.961    305.88116    305.88116    60678.839    60678.839    1255.1085    1255.1085 
Loop time of 195.339 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.261 hours/ns, 5.119 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.4      | 194.4      | 194.4      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15144    | 0.15144    | 0.15144    |   0.0 |  0.08
Output  | 0.00017839 | 0.00017839 | 0.00017839 |   0.0 |  0.00
Modify  | 0.69366    | 0.69366    | 0.69366    |   0.0 |  0.36
Other   |            | 0.09678    |            |       |  0.05

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

Total # of neighbors = 311890
Ave neighs/atom = 77.972500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.757970476719, Press = -0.140861467550941
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -22762.847   -22762.847   -22920.961   -22920.961    305.88116    305.88116    60678.839    60678.839    1255.1085    1255.1085 
   38000   -22757.032   -22757.032   -22919.678   -22919.678    314.65151    314.65151    60724.051    60724.051    184.31856    184.31856 
Loop time of 192.337 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.41     | 191.41     | 191.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14937    | 0.14937    | 0.14937    |   0.0 |  0.08
Output  | 0.00017654 | 0.00017654 | 0.00017654 |   0.0 |  0.00
Modify  | 0.68023    | 0.68023    | 0.68023    |   0.0 |  0.35
Other   |            | 0.0954     |            |       |  0.05

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

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.707075264107, Press = -0.710103252239072
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -22757.032   -22757.032   -22919.678   -22919.678    314.65151    314.65151    60724.051    60724.051    184.31856    184.31856 
   39000    -22763.99    -22763.99   -22924.156   -22924.156    309.85191    309.85191    60753.402    60753.402    -1077.168    -1077.168 
Loop time of 197.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.917 hours/ns, 5.058 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    | 196.74     | 196.74     | 196.74     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15457    | 0.15457    | 0.15457    |   0.0 |  0.08
Output  | 0.00021583 | 0.00021583 | 0.00021583 |   0.0 |  0.00
Modify  | 0.7084     | 0.7084     | 0.7084     |   0.0 |  0.36
Other   |            | 0.09803    |            |       |  0.05

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

Total # of neighbors = 311886
Ave neighs/atom = 77.971500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.658060327423, Press = -1.10014392698454
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -22763.99    -22763.99   -22924.156   -22924.156    309.85191    309.85191    60753.402    60753.402    -1077.168    -1077.168 
   40000   -22756.859   -22756.859   -22920.819   -22920.819    317.19164    317.19164    60822.743    60822.743   -2751.8148   -2751.8148 
Loop time of 192.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.537 hours/ns, 5.188 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.8      | 191.8      | 191.8      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15044    | 0.15044    | 0.15044    |   0.0 |  0.08
Output  | 0.00017556 | 0.00017556 | 0.00017556 |   0.0 |  0.00
Modify  | 0.68349    | 0.68349    | 0.68349    |   0.0 |  0.35
Other   |            | 0.0963     |            |       |  0.05

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

Total # of neighbors = 311906
Ave neighs/atom = 77.976500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.597853977369, Press = -0.00313782315383722
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -22756.859   -22756.859   -22920.819   -22920.819    317.19164    317.19164    60822.743    60822.743   -2751.8148   -2751.8148 
   41000    -22758.59    -22758.59   -22920.691   -22920.691    313.59409    313.59409    60746.408    60746.408   -643.93105   -643.93105 
Loop time of 196.152 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.487 hours/ns, 5.098 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.2      | 195.2      | 195.2      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15415    | 0.15415    | 0.15415    |   0.0 |  0.08
Output  | 0.001491   | 0.001491   | 0.001491   |   0.0 |  0.00
Modify  | 0.69695    | 0.69695    | 0.69695    |   0.0 |  0.36
Other   |            | 0.09617    |            |       |  0.05

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

Total # of neighbors = 311920
Ave neighs/atom = 77.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.551066519048, Press = 1.09716543940202
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    -22758.59    -22758.59   -22920.691   -22920.691    313.59409    313.59409    60746.408    60746.408   -643.93105   -643.93105 
   42000    -22760.39    -22760.39   -22923.083   -22923.083    314.74101    314.74101     60681.61     60681.61    1133.9035    1133.9035 
Loop time of 195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.167 hours/ns, 5.128 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.06     | 194.06     | 194.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15393    | 0.15393    | 0.15393    |   0.0 |  0.08
Output  | 0.00023058 | 0.00023058 | 0.00023058 |   0.0 |  0.00
Modify  | 0.69187    | 0.69187    | 0.69187    |   0.0 |  0.35
Other   |            | 0.0964     |            |       |  0.05

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

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.546612435625, Press = 0.535268898596175
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000    -22760.39    -22760.39   -22923.083   -22923.083    314.74101    314.74101     60681.61     60681.61    1133.9035    1133.9035 
   43000   -22758.309   -22758.309   -22920.371   -22920.371    313.51984    313.51984     60666.55     60666.55    1793.7936    1793.7936 
Loop time of 195.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.399 hours/ns, 5.106 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.89     | 194.89     | 194.89     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15253    | 0.15253    | 0.15253    |   0.0 |  0.08
Output  | 0.0001746  | 0.0001746  | 0.0001746  |   0.0 |  0.00
Modify  | 0.69821    | 0.69821    | 0.69821    |   0.0 |  0.36
Other   |            | 0.09646    |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.480845183323, Press = -0.412645752040701
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -22758.309   -22758.309   -22920.371   -22920.371    313.51984    313.51984     60666.55     60666.55    1793.7936    1793.7936 
   44000   -22762.158   -22762.158   -22923.764   -22923.764    312.63727    312.63727    60711.169    60711.169    197.07089    197.07089 
Loop time of 194.462 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.017 hours/ns, 5.142 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.53     | 193.53     | 193.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15236    | 0.15236    | 0.15236    |   0.0 |  0.08
Output  | 0.00017821 | 0.00017821 | 0.00017821 |   0.0 |  0.00
Modify  | 0.6875     | 0.6875     | 0.6875     |   0.0 |  0.35
Other   |            | 0.0963     |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.469129847978, Press = -1.01302256590099
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -22762.158   -22762.158   -22923.764   -22923.764    312.63727    312.63727    60711.169    60711.169    197.07089    197.07089 
   45000   -22756.788   -22756.788   -22921.111   -22921.111    317.89399    317.89399    60755.327    60755.327   -873.67223   -873.67223 
Loop time of 194.248 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.958 hours/ns, 5.148 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    | 193.31     | 193.31     | 193.31     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15031    | 0.15031    | 0.15031    |   0.0 |  0.08
Output  | 0.00018431 | 0.00018431 | 0.00018431 |   0.0 |  0.00
Modify  | 0.68945    | 0.68945    | 0.68945    |   0.0 |  0.35
Other   |            | 0.09785    |            |       |  0.05

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

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.470036460864, Press = -0.733789443103922
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -22756.788   -22756.788   -22921.111   -22921.111    317.89399    317.89399    60755.327    60755.327   -873.67223   -873.67223 
   46000   -22753.461   -22753.461   -22917.978   -22917.978    318.26983    318.26983    60746.803    60746.803   -430.98168   -430.98168 
Loop time of 194.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.118 hours/ns, 5.133 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.88     | 193.88     | 193.88     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15161    | 0.15161    | 0.15161    |   0.0 |  0.08
Output  | 0.00017692 | 0.00017692 | 0.00017692 |   0.0 |  0.00
Modify  | 0.69388    | 0.69388    | 0.69388    |   0.0 |  0.36
Other   |            | 0.09703    |            |       |  0.05

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

Total # of neighbors = 311910
Ave neighs/atom = 77.977500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.457399367149, Press = -0.202862914569596
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -22753.461   -22753.461   -22917.978   -22917.978    318.26983    318.26983    60746.803    60746.803   -430.98168   -430.98168 
   47000   -22759.883   -22759.883   -22925.043   -22925.043    319.51317    319.51317    60723.154    60723.154   -329.43344   -329.43344 
Loop time of 194.453 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.015 hours/ns, 5.143 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.52     | 193.52     | 193.52     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15226    | 0.15226    | 0.15226    |   0.0 |  0.08
Output  | 0.00017765 | 0.00017765 | 0.00017765 |   0.0 |  0.00
Modify  | 0.6874     | 0.6874     | 0.6874     |   0.0 |  0.35
Other   |            | 0.09659    |            |       |  0.05

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

Total # of neighbors = 311898
Ave neighs/atom = 77.974500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.496832307074, Press = -0.185218709275572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -22759.883   -22759.883   -22925.043   -22925.043    319.51317    319.51317    60723.154    60723.154   -329.43344   -329.43344 
   48000   -22756.091   -22756.091   -22921.749   -22921.749    320.47539    320.47539    60740.475    60740.475   -483.50782   -483.50782 
Loop time of 197.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 54.991 hours/ns, 5.051 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.01     | 197.01     | 197.01     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15384    | 0.15384    | 0.15384    |   0.0 |  0.08
Output  | 0.00017526 | 0.00017526 | 0.00017526 |   0.0 |  0.00
Modify  | 0.70956    | 0.70956    | 0.70956    |   0.0 |  0.36
Other   |            | 0.09721    |            |       |  0.05

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

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.494404416907, Press = -0.00236010750883189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -22756.091   -22756.091   -22921.749   -22921.749    320.47539    320.47539    60740.475    60740.475   -483.50782   -483.50782 
   49000   -22759.411   -22759.411   -22923.986   -22923.986    318.38112    318.38112    60655.137    60655.137    1823.2924    1823.2924 
Loop time of 199.829 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.508 hours/ns, 5.004 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    | 198.86     | 198.86     | 198.86     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15519    | 0.15519    | 0.15519    |   0.0 |  0.08
Output  | 0.00017437 | 0.00017437 | 0.00017437 |   0.0 |  0.00
Modify  | 0.71602    | 0.71602    | 0.71602    |   0.0 |  0.36
Other   |            | 0.09873    |            |       |  0.05

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

Total # of neighbors = 311892
Ave neighs/atom = 77.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.501253609508, Press = 0.385641625925688
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -22759.411   -22759.411   -22923.986   -22923.986    318.38112    318.38112    60655.137    60655.137    1823.2924    1823.2924 
   50000   -22757.698   -22757.698   -22920.283   -22920.283    314.53127    314.53127    60652.324    60652.324    2107.7878    2107.7878 
Loop time of 195.778 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.383 hours/ns, 5.108 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.83     | 194.83     | 194.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15282    | 0.15282    | 0.15282    |   0.0 |  0.08
Output  | 0.00022566 | 0.00022566 | 0.00022566 |   0.0 |  0.00
Modify  | 0.69674    | 0.69674    | 0.69674    |   0.0 |  0.36
Other   |            | 0.09806    |            |       |  0.05

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

Total # of neighbors = 311922
Ave neighs/atom = 77.980500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.535507053605, Press = -0.828866066238075
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -22757.698   -22757.698   -22920.283   -22920.283    314.53127    314.53127    60652.324    60652.324    2107.7878    2107.7878 
   51000    -22757.61    -22757.61   -22922.861   -22922.861    319.68835    319.68835    60732.474    60732.474   -298.90887   -298.90887 
Loop time of 195.092 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.192 hours/ns, 5.126 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.15     | 194.15     | 194.15     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15274    | 0.15274    | 0.15274    |   0.0 |  0.08
Output  | 0.00017767 | 0.00017767 | 0.00017767 |   0.0 |  0.00
Modify  | 0.69522    | 0.69522    | 0.69522    |   0.0 |  0.36
Other   |            | 0.09731    |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.524165779508, Press = -1.01104616742516
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000    -22757.61    -22757.61   -22922.861   -22922.861    319.68835    319.68835    60732.474    60732.474   -298.90887   -298.90887 
   52000   -22760.606   -22760.606   -22920.603   -22920.603    309.52465    309.52465    60751.047    60751.047   -884.22153   -884.22153 
Loop time of 194.347 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.985 hours/ns, 5.145 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.41     | 193.41     | 193.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15139    | 0.15139    | 0.15139    |   0.0 |  0.08
Output  | 0.00017802 | 0.00017802 | 0.00017802 |   0.0 |  0.00
Modify  | 0.69213    | 0.69213    | 0.69213    |   0.0 |  0.36
Other   |            | 0.09686    |            |       |  0.05

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

Total # of neighbors = 311900
Ave neighs/atom = 77.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.530886133027, Press = -0.723908438939206
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -22760.606   -22760.606   -22920.603   -22920.603    309.52465    309.52465    60751.047    60751.047   -884.22153   -884.22153 
   53000   -22753.344   -22753.344   -22918.721   -22918.721    319.93297    319.93297      60780.6      60780.6   -1387.5903   -1387.5903 
Loop time of 193.843 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.91     | 192.91     | 192.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15194    | 0.15194    | 0.15194    |   0.0 |  0.08
Output  | 0.00017643 | 0.00017643 | 0.00017643 |   0.0 |  0.00
Modify  | 0.68714    | 0.68714    | 0.68714    |   0.0 |  0.35
Other   |            | 0.09647    |            |       |  0.05

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

Total # of neighbors = 311916
Ave neighs/atom = 77.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.564313246401, Press = -0.0199909783629987
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -22753.344   -22753.344   -22918.721   -22918.721    319.93297    319.93297      60780.6      60780.6   -1387.5903   -1387.5903 
   54000   -22758.226   -22758.226   -22919.782   -22919.782    312.54088    312.54088    60725.317    60725.317   -32.518061   -32.518061 
Loop time of 196.535 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.593 hours/ns, 5.088 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.59     | 195.59     | 195.59     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15219    | 0.15219    | 0.15219    |   0.0 |  0.08
Output  | 0.0002337  | 0.0002337  | 0.0002337  |   0.0 |  0.00
Modify  | 0.69761    | 0.69761    | 0.69761    |   0.0 |  0.35
Other   |            | 0.09732    |            |       |  0.05

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

Total # of neighbors = 311906
Ave neighs/atom = 77.976500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.567309740498, Press = 0.191529709847096
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -22758.226   -22758.226   -22919.782   -22919.782    312.54088    312.54088    60725.317    60725.317   -32.518061   -32.518061 
   55000   -22765.733   -22765.733   -22924.601   -22924.601    307.34097    307.34097    60715.659    60715.659   -208.10506   -208.10506 
Loop time of 195.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.364 hours/ns, 5.110 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.77     | 194.77     | 194.77     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15274    | 0.15274    | 0.15274    |   0.0 |  0.08
Output  | 0.0002246  | 0.0002246  | 0.0002246  |   0.0 |  0.00
Modify  | 0.69652    | 0.69652    | 0.69652    |   0.0 |  0.36
Other   |            | 0.09617    |            |       |  0.05

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

Total # of neighbors = 311888
Ave neighs/atom = 77.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.560828986281, Press = -0.315658296331286
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -22765.733   -22765.733   -22924.601   -22924.601    307.34097    307.34097    60715.659    60715.659   -208.10506   -208.10506 
   56000   -22756.201   -22756.201   -22919.004   -22919.004    314.95315    314.95315    60718.131    60718.131    245.01815    245.01815 
Loop time of 195.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.425 hours/ns, 5.104 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.98     | 194.98     | 194.98     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15427    | 0.15427    | 0.15427    |   0.0 |  0.08
Output  | 0.00022096 | 0.00022096 | 0.00022096 |   0.0 |  0.00
Modify  | 0.69982    | 0.69982    | 0.69982    |   0.0 |  0.36
Other   |            | 0.09761    |            |       |  0.05

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

Total # of neighbors = 311916
Ave neighs/atom = 77.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.517917630917, Press = -0.379208344456823
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -22756.201   -22756.201   -22919.004   -22919.004    314.95315    314.95315    60718.131    60718.131    245.01815    245.01815 
   57000   -22757.504   -22757.504   -22920.898   -22920.898    316.09697    316.09697    60726.737    60726.737    -82.74561    -82.74561 
Loop time of 194.992 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.164 hours/ns, 5.128 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.05     | 194.05     | 194.05     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15227    | 0.15227    | 0.15227    |   0.0 |  0.08
Output  | 0.00017711 | 0.00017711 | 0.00017711 |   0.0 |  0.00
Modify  | 0.69053    | 0.69053    | 0.69053    |   0.0 |  0.35
Other   |            | 0.09629    |            |       |  0.05

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

Total # of neighbors = 311920
Ave neighs/atom = 77.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.520665211926, Press = -0.54736389201225
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -22757.504   -22757.504   -22920.898   -22920.898    316.09697    316.09697    60726.737    60726.737    -82.74561    -82.74561 
   58000    -22758.32    -22758.32   -22919.052   -22919.052    310.94741    310.94741    60750.276    60750.276   -706.64472   -706.64472 
Loop time of 196.116 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.477 hours/ns, 5.099 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.17     | 195.17     | 195.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15363    | 0.15363    | 0.15363    |   0.0 |  0.08
Output  | 0.0002167  | 0.0002167  | 0.0002167  |   0.0 |  0.00
Modify  | 0.69737    | 0.69737    | 0.69737    |   0.0 |  0.36
Other   |            | 0.09638    |            |       |  0.05

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

Total # of neighbors = 311892
Ave neighs/atom = 77.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.560521299023, Press = -0.54915876577573
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000    -22758.32    -22758.32   -22919.052   -22919.052    310.94741    310.94741    60750.276    60750.276   -706.64472   -706.64472 
   59000   -22755.906   -22755.906   -22919.965   -22919.965    317.38245    317.38245    60777.868    60777.868   -1478.5557   -1478.5557 
Loop time of 196.911 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.697 hours/ns, 5.078 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.95     | 195.95     | 195.95     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15406    | 0.15406    | 0.15406    |   0.0 |  0.08
Output  | 0.00017205 | 0.00017205 | 0.00017205 |   0.0 |  0.00
Modify  | 0.70546    | 0.70546    | 0.70546    |   0.0 |  0.36
Other   |            | 0.09716    |            |       |  0.05

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

Total # of neighbors = 311932
Ave neighs/atom = 77.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.566663418564, Press = -0.201151526201366
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -22755.906   -22755.906   -22919.965   -22919.965    317.38245    317.38245    60777.868    60777.868   -1478.5557   -1478.5557 
   60000   -22761.291   -22761.291   -22921.215   -22921.215     309.3835     309.3835    60751.844    60751.844   -841.77997   -841.77997 
Loop time of 196.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.494 hours/ns, 5.097 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.23     | 195.23     | 195.23     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15345    | 0.15345    | 0.15345    |   0.0 |  0.08
Output  | 0.00017788 | 0.00017788 | 0.00017788 |   0.0 |  0.00
Modify  | 0.69665    | 0.69665    | 0.69665    |   0.0 |  0.36
Other   |            | 0.09626    |            |       |  0.05

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

Total # of neighbors = 311896
Ave neighs/atom = 77.974000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.603317630405, Press = 0.406321558732801
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -22761.291   -22761.291   -22921.215   -22921.215     309.3835     309.3835    60751.844    60751.844   -841.77997   -841.77997 
   61000   -22756.373   -22756.373   -22919.494   -22919.494     315.5703     315.5703    60698.014    60698.014    968.31691    968.31691 
Loop time of 199.029 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.286 hours/ns, 5.024 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    | 198.06     | 198.06     | 198.06     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15548    | 0.15548    | 0.15548    |   0.0 |  0.08
Output  | 0.0001773  | 0.0001773  | 0.0001773  |   0.0 |  0.00
Modify  | 0.71425    | 0.71425    | 0.71425    |   0.0 |  0.36
Other   |            | 0.09729    |            |       |  0.05

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

Total # of neighbors = 311888
Ave neighs/atom = 77.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.601973490445, Press = 0.434790102303902
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -22756.373   -22756.373   -22919.494   -22919.494     315.5703     315.5703    60698.014    60698.014    968.31691    968.31691 
   62000   -22761.062   -22761.062     -22924.4     -22924.4    315.98796    315.98796    60687.579    60687.579    806.75196    806.75196 
Loop time of 197.624 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.896 hours/ns, 5.060 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    | 196.67     | 196.67     | 196.67     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15489    | 0.15489    | 0.15489    |   0.0 |  0.08
Output  | 0.00017656 | 0.00017656 | 0.00017656 |   0.0 |  0.00
Modify  | 0.70644    | 0.70644    | 0.70644    |   0.0 |  0.36
Other   |            | 0.09715    |            |       |  0.05

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

Total # of neighbors = 311916
Ave neighs/atom = 77.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.557716978081, Press = -0.319343268955599
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -22761.062   -22761.062     -22924.4     -22924.4    315.98796    315.98796    60687.579    60687.579    806.75196    806.75196 
   63000   -22755.601   -22755.601   -22918.339   -22918.339    314.82798    314.82798    60721.778    60721.778    315.42502    315.42502 
Loop time of 195.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.384 hours/ns, 5.108 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.83     | 194.83     | 194.83     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15419    | 0.15419    | 0.15419    |   0.0 |  0.08
Output  | 0.00022526 | 0.00022526 | 0.00022526 |   0.0 |  0.00
Modify  | 0.70232    | 0.70232    | 0.70232    |   0.0 |  0.36
Other   |            | 0.09715    |            |       |  0.05

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

Total # of neighbors = 311906
Ave neighs/atom = 77.976500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.550784455463, Press = -0.698372386334074
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -22755.601   -22755.601   -22918.339   -22918.339    314.82798    314.82798    60721.778    60721.778    315.42502    315.42502 
   64000    -22761.07    -22761.07   -22920.694   -22920.694    308.80166    308.80166     60754.07     60754.07   -924.32148   -924.32148 
Loop time of 194.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.925 hours/ns, 5.151 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.19     | 193.19     | 193.19     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15259    | 0.15259    | 0.15259    |   0.0 |  0.08
Output  | 0.00017922 | 0.00017922 | 0.00017922 |   0.0 |  0.00
Modify  | 0.69       | 0.69       | 0.69       |   0.0 |  0.36
Other   |            | 0.09669    |            |       |  0.05

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

Total # of neighbors = 311894
Ave neighs/atom = 77.973500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.55968949704, Press = -0.476837427423229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000    -22761.07    -22761.07   -22920.694   -22920.694    308.80166    308.80166     60754.07     60754.07   -924.32148   -924.32148 
   65000   -22757.627   -22757.627   -22920.655   -22920.655    315.38872    315.38872    60760.937    60760.937   -1048.6331   -1048.6331 
Loop time of 193.878 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.94     | 192.94     | 192.94     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15225    | 0.15225    | 0.15225    |   0.0 |  0.08
Output  | 0.00017418 | 0.00017418 | 0.00017418 |   0.0 |  0.00
Modify  | 0.68802    | 0.68802    | 0.68802    |   0.0 |  0.35
Other   |            | 0.09693    |            |       |  0.05

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

Total # of neighbors = 311878
Ave neighs/atom = 77.969500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.590302265213, Press = -0.117777172414545
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -22757.627   -22757.627   -22920.655   -22920.655    315.38872    315.38872    60760.937    60760.937   -1048.6331   -1048.6331 
   66000   -22757.353   -22757.353    -22919.39    -22919.39    313.47241    313.47241    60726.839    60726.839    53.935828    53.935828 
Loop time of 194.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.983 hours/ns, 5.146 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.4      | 193.4      | 193.4      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15157    | 0.15157    | 0.15157    |   0.0 |  0.08
Output  | 0.00017923 | 0.00017923 | 0.00017923 |   0.0 |  0.00
Modify  | 0.68889    | 0.68889    | 0.68889    |   0.0 |  0.35
Other   |            | 0.09582    |            |       |  0.05

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

Total # of neighbors = 311916
Ave neighs/atom = 77.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.595873542247, Press = 0.702090562271435
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -22757.353   -22757.353    -22919.39    -22919.39    313.47241    313.47241    60726.839    60726.839    53.935828    53.935828 
   67000    -22758.69    -22758.69   -22922.238   -22922.238    316.39423    316.39423    60654.552    60654.552    1980.3803    1980.3803 
Loop time of 205.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.009 hours/ns, 4.872 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.23     | 204.23     | 204.23     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15942    | 0.15942    | 0.15942    |   0.0 |  0.08
Output  | 0.00050825 | 0.00050825 | 0.00050825 |   0.0 |  0.00
Modify  | 0.74048    | 0.74048    | 0.74048    |   0.0 |  0.36
Other   |            | 0.09922    |            |       |  0.05

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

Total # of neighbors = 311900
Ave neighs/atom = 77.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.626852414764, Press = 0.228811832948449
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000    -22758.69    -22758.69   -22922.238   -22922.238    316.39423    316.39423    60654.552    60654.552    1980.3803    1980.3803 
   68000   -22757.263   -22757.263   -22918.469   -22918.469    311.86472    311.86472     60679.03     60679.03    1537.0364    1537.0364 
Loop time of 206.752 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.431 hours/ns, 4.837 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.74     | 205.74     | 205.74     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16019    | 0.16019    | 0.16019    |   0.0 |  0.08
Output  | 0.00019023 | 0.00019023 | 0.00019023 |   0.0 |  0.00
Modify  | 0.75321    | 0.75321    | 0.75321    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.606620277132, Press = -0.324354098912582
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -22757.263   -22757.263   -22918.469   -22918.469    311.86472    311.86472     60679.03     60679.03    1537.0364    1537.0364 
   69000   -22762.573   -22762.573   -22923.445   -22923.445    311.21877    311.21877    60689.611    60689.611    778.53149    778.53149 
Loop time of 199.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.357 hours/ns, 5.018 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.32     | 198.32     | 198.32     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15521    | 0.15521    | 0.15521    |   0.0 |  0.08
Output  | 0.00017787 | 0.00017787 | 0.00017787 |   0.0 |  0.00
Modify  | 0.71609    | 0.71609    | 0.71609    |   0.0 |  0.36
Other   |            | 0.09794    |            |       |  0.05

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

Total # of neighbors = 311936
Ave neighs/atom = 77.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.565868631104, Press = -0.55006368062714
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -22762.573   -22762.573   -22923.445   -22923.445    311.21877    311.21877    60689.611    60689.611    778.53149    778.53149 
   70000   -22758.344   -22758.344   -22921.046   -22921.046    314.75743    314.75743    60741.668    60741.668   -490.97716   -490.97716 
Loop time of 201.971 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.99     | 200.99     | 200.99     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15699    | 0.15699    | 0.15699    |   0.0 |  0.08
Output  | 0.00017966 | 0.00017966 | 0.00017966 |   0.0 |  0.00
Modify  | 0.72717    | 0.72717    | 0.72717    |   0.0 |  0.36
Other   |            | 0.09864    |            |       |  0.05

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

Total # of neighbors = 311902
Ave neighs/atom = 77.975500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.552373220187, Press = -0.708327621107767
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -22758.344   -22758.344   -22921.046   -22921.046    314.75743    314.75743    60741.668    60741.668   -490.97716   -490.97716 
   71000   -22760.497   -22760.497   -22920.696   -22920.696    309.91616    309.91616    60750.301    60750.301   -799.41382   -799.41382 
Loop time of 193.464 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.447 ns/day, 53.740 hours/ns, 5.169 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.53     | 192.53     | 192.53     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15247    | 0.15247    | 0.15247    |   0.0 |  0.08
Output  | 0.00017397 | 0.00017397 | 0.00017397 |   0.0 |  0.00
Modify  | 0.68589    | 0.68589    | 0.68589    |   0.0 |  0.35
Other   |            | 0.09686    |            |       |  0.05

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

Total # of neighbors = 311906
Ave neighs/atom = 77.976500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.527400595866, Press = -0.380534592555863
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -22760.497   -22760.497   -22920.696   -22920.696    309.91616    309.91616    60750.301    60750.301   -799.41382   -799.41382 
   72000   -22760.741   -22760.741   -22920.997   -22920.997    310.02548    310.02548    60731.126    60731.126    -228.0469    -228.0469 
Loop time of 198.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.118 hours/ns, 5.040 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.47     | 197.47     | 197.47     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15346    | 0.15346    | 0.15346    |   0.0 |  0.08
Output  | 0.00017666 | 0.00017666 | 0.00017666 |   0.0 |  0.00
Modify  | 0.70614    | 0.70614    | 0.70614    |   0.0 |  0.36
Other   |            | 0.09748    |            |       |  0.05

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

Total # of neighbors = 311902
Ave neighs/atom = 77.975500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.511487316484, Press = -0.187369414603711
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -22760.741   -22760.741   -22920.997   -22920.997    310.02548    310.02548    60731.126    60731.126    -228.0469    -228.0469 
   73000   -22757.844   -22757.844   -22920.019   -22920.019    313.73824    313.73824    60720.332    60720.332    215.35407    215.35407 
Loop time of 198.198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.055 hours/ns, 5.045 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.24     | 197.24     | 197.24     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15492    | 0.15492    | 0.15492    |   0.0 |  0.08
Output  | 0.00017838 | 0.00017838 | 0.00017838 |   0.0 |  0.00
Modify  | 0.70906    | 0.70906    | 0.70906    |   0.0 |  0.36
Other   |            | 0.09731    |            |       |  0.05

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

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.470695734284, Press = -0.118509579416403
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -22757.844   -22757.844   -22920.019   -22920.019    313.73824    313.73824    60720.332    60720.332    215.35407    215.35407 
   74000   -22763.506   -22763.506   -22924.711   -22924.711    311.86275    311.86275    60700.685    60700.685    421.83175    421.83175 
Loop time of 196.14 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.483 hours/ns, 5.098 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.19     | 195.19     | 195.19     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15201    | 0.15201    | 0.15201    |   0.0 |  0.08
Output  | 0.00018006 | 0.00018006 | 0.00018006 |   0.0 |  0.00
Modify  | 0.7003     | 0.7003     | 0.7003     |   0.0 |  0.36
Other   |            | 0.0971     |            |       |  0.05

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

Total # of neighbors = 311892
Ave neighs/atom = 77.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.452724869481, Press = -0.101176772391231
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -22763.506   -22763.506   -22924.711   -22924.711    311.86275    311.86275    60700.685    60700.685    421.83175    421.83175 
   75000   -22759.441   -22759.441   -22921.769   -22921.769    314.03455    314.03455    60679.857    60679.857    1255.0249    1255.0249 
Loop time of 198.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.045 hours/ns, 5.046 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.2      | 197.2      | 197.2      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15405    | 0.15405    | 0.15405    |   0.0 |  0.08
Output  | 0.00017538 | 0.00017538 | 0.00017538 |   0.0 |  0.00
Modify  | 0.7081     | 0.7081     | 0.7081     |   0.0 |  0.36
Other   |            | 0.09796    |            |       |  0.05

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

Total # of neighbors = 311934
Ave neighs/atom = 77.983500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.457875659432, Press = -0.147376226970362
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -22759.441   -22759.441   -22921.769   -22921.769    314.03455    314.03455    60679.857    60679.857    1255.0249    1255.0249 
   76000   -22753.752   -22753.752   -22917.886   -22917.886    317.52687    317.52687    60703.571    60703.571    897.72082    897.72082 
Loop time of 199.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.551 hours/ns, 5.000 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.01     | 199.01     | 199.01     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15595    | 0.15595    | 0.15595    |   0.0 |  0.08
Output  | 0.00017736 | 0.00017736 | 0.00017736 |   0.0 |  0.00
Modify  | 0.72075    | 0.72075    | 0.72075    |   0.0 |  0.36
Other   |            | 0.09913    |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.472748163684, Press = -0.538637395786118
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -22753.752   -22753.752   -22917.886   -22917.886    317.52687    317.52687    60703.571    60703.571    897.72082    897.72082 
   77000   -22759.688   -22759.688   -22920.028   -22920.028    310.18868    310.18868    60759.576    60759.576   -1063.3321   -1063.3321 
Loop time of 202.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.201 hours/ns, 4.943 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    | 201.34     | 201.34     | 201.34     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15865    | 0.15865    | 0.15865    |   0.0 |  0.08
Output  | 0.00017776 | 0.00017776 | 0.00017776 |   0.0 |  0.00
Modify  | 0.72961    | 0.72961    | 0.72961    |   0.0 |  0.36
Other   |            | 0.09914    |            |       |  0.05

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

Total # of neighbors = 311906
Ave neighs/atom = 77.976500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.490867925815, Press = -0.829757864227177
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -22759.688   -22759.688   -22920.028   -22920.028    310.18868    310.18868    60759.576    60759.576   -1063.3321   -1063.3321 
   78000    -22760.14    -22760.14   -22921.115   -22921.115    311.41733    311.41733    60805.651    60805.651   -2453.8137   -2453.8137 
Loop time of 203.146 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.429 hours/ns, 4.923 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.16     | 202.16     | 202.16     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15595    | 0.15595    | 0.15595    |   0.0 |  0.08
Output  | 0.00028358 | 0.00028358 | 0.00028358 |   0.0 |  0.00
Modify  | 0.732      | 0.732      | 0.732      |   0.0 |  0.36
Other   |            | 0.0986     |            |       |  0.05

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

Total # of neighbors = 311880
Ave neighs/atom = 77.970000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.489423561189, Press = -0.42368289729602
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000    -22760.14    -22760.14   -22921.115   -22921.115    311.41733    311.41733    60805.651    60805.651   -2453.8137   -2453.8137 
   79000   -22755.116   -22755.116   -22920.385   -22920.385    319.72473    319.72473    60755.307    60755.307   -809.02975   -809.02975 
Loop time of 199.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.494 hours/ns, 5.006 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.82     | 198.82     | 198.82     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15572    | 0.15572    | 0.15572    |   0.0 |  0.08
Output  | 0.00022254 | 0.00022254 | 0.00022254 |   0.0 |  0.00
Modify  | 0.71069    | 0.71069    | 0.71069    |   0.0 |  0.36
Other   |            | 0.09689    |            |       |  0.05

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

Total # of neighbors = 311894
Ave neighs/atom = 77.973500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.477111194254, Press = 0.0663860529125444
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -22755.116   -22755.116   -22920.385   -22920.385    319.72473    319.72473    60755.307    60755.307   -809.02975   -809.02975 
   80000   -22756.574   -22756.574    -22918.08    -22918.08    312.44453    312.44453    60711.792    60711.792    602.70435    602.70435 
Loop time of 202.228 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.174 hours/ns, 4.945 timesteps/s
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    | 201.24     | 201.24     | 201.24     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15675    | 0.15675    | 0.15675    |   0.0 |  0.08
Output  | 0.00017743 | 0.00017743 | 0.00017743 |   0.0 |  0.00
Modify  | 0.73016    | 0.73016    | 0.73016    |   0.0 |  0.36
Other   |            | 0.09944    |            |       |  0.05

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

Total # of neighbors = 311934
Ave neighs/atom = 77.983500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.479997289832, Press = -0.040687796297907
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -22756.574   -22756.574    -22918.08    -22918.08    312.44453    312.44453    60711.792    60711.792    602.70435    602.70435 
   81000   -22758.969   -22758.969   -22920.152   -22920.152     311.8193     311.8193    60700.928    60700.928    717.96368    717.96368 
Loop time of 203.624 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.64     | 202.64     | 202.64     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15774    | 0.15774    | 0.15774    |   0.0 |  0.08
Output  | 0.00017729 | 0.00017729 | 0.00017729 |   0.0 |  0.00
Modify  | 0.73282    | 0.73282    | 0.73282    |   0.0 |  0.36
Other   |            | 0.09777    |            |       |  0.05

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

Total # of neighbors = 311888
Ave neighs/atom = 77.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.508296751428, Press = -0.231180659557299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -22758.969   -22758.969   -22920.152   -22920.152     311.8193     311.8193    60700.928    60700.928    717.96368    717.96368 
   82000    -22756.33    -22756.33   -22919.246   -22919.246    315.17153    315.17153    60711.786    60711.786    435.97186    435.97186 
Loop time of 200.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.807 hours/ns, 4.977 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    | 199.93     | 199.93     | 199.93     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15597    | 0.15597    | 0.15597    |   0.0 |  0.08
Output  | 0.00017636 | 0.00017636 | 0.00017636 |   0.0 |  0.00
Modify  | 0.72358    | 0.72358    | 0.72358    |   0.0 |  0.36
Other   |            | 0.09802    |            |       |  0.05

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

Total # of neighbors = 311920
Ave neighs/atom = 77.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.506537947724, Press = -0.451988944271239
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000    -22756.33    -22756.33   -22919.246   -22919.246    315.17153    315.17153    60711.786    60711.786    435.97186    435.97186 
   83000   -22759.836   -22759.836   -22918.075   -22918.075    306.12329    306.12329    60748.049    60748.049    -493.8201    -493.8201 
Loop time of 199.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.336 hours/ns, 5.020 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.24     | 198.24     | 198.24     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15503    | 0.15503    | 0.15503    |   0.0 |  0.08
Output  | 0.00017924 | 0.00017924 | 0.00017924 |   0.0 |  0.00
Modify  | 0.71419    | 0.71419    | 0.71419    |   0.0 |  0.36
Other   |            | 0.09802    |            |       |  0.05

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

Total # of neighbors = 311886
Ave neighs/atom = 77.971500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.476756805726, Press = -0.583052665695775
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -22759.836   -22759.836   -22918.075   -22918.075    306.12329    306.12329    60748.049    60748.049    -493.8201    -493.8201 
   84000   -22759.798   -22759.798   -22919.905   -22919.905    309.73754    309.73754    60778.839    60778.839   -1528.7378   -1528.7378 
Loop time of 203.075 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.410 hours/ns, 4.924 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.09     | 202.09     | 202.09     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15795    | 0.15795    | 0.15795    |   0.0 |  0.08
Output  | 0.00023843 | 0.00023843 | 0.00023843 |   0.0 |  0.00
Modify  | 0.72832    | 0.72832    | 0.72832    |   0.0 |  0.36
Other   |            | 0.09874    |            |       |  0.05

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

Total # of neighbors = 311876
Ave neighs/atom = 77.969000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.475558813997, Press = -0.2099502828237
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -22759.798   -22759.798   -22919.905   -22919.905    309.73754    309.73754    60778.839    60778.839   -1528.7378   -1528.7378 
   85000   -22755.509   -22755.509   -22918.526   -22918.526    315.36721    315.36721    60750.825    60750.825   -580.20443   -580.20443 
Loop time of 194.189 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.941 hours/ns, 5.150 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.25     | 193.25     | 193.25     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15215    | 0.15215    | 0.15215    |   0.0 |  0.08
Output  | 0.0001763  | 0.0001763  | 0.0001763  |   0.0 |  0.00
Modify  | 0.68909    | 0.68909    | 0.68909    |   0.0 |  0.35
Other   |            | 0.09567    |            |       |  0.05

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

Total # of neighbors = 311886
Ave neighs/atom = 77.971500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.469473111318, Press = 0.215568744803972
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -22755.509   -22755.509   -22918.526   -22918.526    315.36721    315.36721    60750.825    60750.825   -580.20443   -580.20443 
   86000   -22759.306   -22759.306   -22920.811   -22920.811    312.44373    312.44373     60691.32     60691.32    937.19695    937.19695 
Loop time of 203.487 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.524 hours/ns, 4.914 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.49     | 202.49     | 202.49     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15929    | 0.15929    | 0.15929    |   0.0 |  0.08
Output  | 0.00023833 | 0.00023833 | 0.00023833 |   0.0 |  0.00
Modify  | 0.73736    | 0.73736    | 0.73736    |   0.0 |  0.36
Other   |            | 0.09973    |            |       |  0.05

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

Total # of neighbors = 311860
Ave neighs/atom = 77.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.480461188397, Press = 0.181112309835395
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -22759.306   -22759.306   -22920.811   -22920.811    312.44373    312.44373     60691.32     60691.32    937.19695    937.19695 
   87000   -22759.886   -22759.886   -22920.332   -22920.332    310.39347    310.39347     60678.33     60678.33    1346.9007    1346.9007 
Loop time of 197.065 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.11     | 196.11     | 196.11     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15508    | 0.15508    | 0.15508    |   0.0 |  0.08
Output  | 0.00023072 | 0.00023072 | 0.00023072 |   0.0 |  0.00
Modify  | 0.70472    | 0.70472    | 0.70472    |   0.0 |  0.36
Other   |            | 0.09724    |            |       |  0.05

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

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.504684791157, Press = -0.195060343885043
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -22759.886   -22759.886   -22920.332   -22920.332    310.39347    310.39347     60678.33     60678.33    1346.9007    1346.9007 
   88000   -22754.096   -22754.096   -22916.726   -22916.726    314.61895    314.61895    60708.904    60708.904    892.82598    892.82598 
Loop time of 193.646 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.71     | 192.71     | 192.71     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15118    | 0.15118    | 0.15118    |   0.0 |  0.08
Output  | 0.00017865 | 0.00017865 | 0.00017865 |   0.0 |  0.00
Modify  | 0.68454    | 0.68454    | 0.68454    |   0.0 |  0.35
Other   |            | 0.09508    |            |       |  0.05

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

Total # of neighbors = 311922
Ave neighs/atom = 77.980500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.50827755837, Press = -0.409433325644636
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -22754.096   -22754.096   -22916.726   -22916.726    314.61895    314.61895    60708.904    60708.904    892.82598    892.82598 
   89000   -22758.819   -22758.819   -22921.019   -22921.019    313.78759    313.78759    60718.739    60718.739     154.9303     154.9303 
Loop time of 198.328 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.091 hours/ns, 5.042 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.36     | 197.36     | 197.36     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15479    | 0.15479    | 0.15479    |   0.0 |  0.08
Output  | 0.00017799 | 0.00017799 | 0.00017799 |   0.0 |  0.00
Modify  | 0.71295    | 0.71295    | 0.71295    |   0.0 |  0.36
Other   |            | 0.09716    |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.491554218444, Press = -0.464029424257889
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -22758.819   -22758.819   -22921.019   -22921.019    313.78759    313.78759    60718.739    60718.739     154.9303     154.9303 
   90000   -22765.112   -22765.112   -22922.408   -22922.408    304.29914    304.29914    60733.334    60733.334   -553.11974   -553.11974 
Loop time of 199.378 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.383 hours/ns, 5.016 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.41     | 198.41     | 198.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15597    | 0.15597    | 0.15597    |   0.0 |  0.08
Output  | 0.00017923 | 0.00017923 | 0.00017923 |   0.0 |  0.00
Modify  | 0.71283    | 0.71283    | 0.71283    |   0.0 |  0.36
Other   |            | 0.09775    |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.475796379651, Press = -0.332864769292777
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -22765.112   -22765.112   -22922.408   -22922.408    304.29914    304.29914    60733.334    60733.334   -553.11974   -553.11974 
   91000   -22756.039   -22756.039    -22921.53    -22921.53    320.15463    320.15463    60767.732    60767.732   -1260.6667   -1260.6667 
Loop time of 192.427 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.49     | 191.49     | 191.49     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1525     | 0.1525     | 0.1525     |   0.0 |  0.08
Output  | 0.00018126 | 0.00018126 | 0.00018126 |   0.0 |  0.00
Modify  | 0.69096    | 0.69096    | 0.69096    |   0.0 |  0.36
Other   |            | 0.09554    |            |       |  0.05

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

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.459113333009, Press = -0.00888658538074952
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -22756.039   -22756.039    -22921.53    -22921.53    320.15463    320.15463    60767.732    60767.732   -1260.6667   -1260.6667 
   92000   -22761.803   -22761.803   -22924.088   -22924.088    313.95279    313.95279    60732.016    60732.016   -506.81956   -506.81956 
Loop time of 191.334 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.452 ns/day, 53.148 hours/ns, 5.226 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.41     | 190.41     | 190.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15022    | 0.15022    | 0.15022    |   0.0 |  0.08
Output  | 0.00021744 | 0.00021744 | 0.00021744 |   0.0 |  0.00
Modify  | 0.67567    | 0.67567    | 0.67567    |   0.0 |  0.35
Other   |            | 0.09576    |            |       |  0.05

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

Total # of neighbors = 311894
Ave neighs/atom = 77.973500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.455605890246, Press = 0.483649288745586
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -22761.803   -22761.803   -22924.088   -22924.088    313.95279    313.95279    60732.016    60732.016   -506.81956   -506.81956 
   93000     -22758.2     -22758.2   -22922.765   -22922.765     318.3617     318.3617     60680.64     60680.64    1144.2891    1144.2891 
Loop time of 192.407 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.48     | 191.48     | 191.48     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15192    | 0.15192    | 0.15192    |   0.0 |  0.08
Output  | 0.00017939 | 0.00017939 | 0.00017939 |   0.0 |  0.00
Modify  | 0.68194    | 0.68194    | 0.68194    |   0.0 |  0.35
Other   |            | 0.09534    |            |       |  0.05

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

Total # of neighbors = 311918
Ave neighs/atom = 77.979500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.454720792965, Press = 0.126451671163635
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000     -22758.2     -22758.2   -22922.765   -22922.765     318.3617     318.3617     60680.64     60680.64    1144.2891    1144.2891 
   94000   -22757.989   -22757.989   -22920.375   -22920.375    314.14522    314.14522    60693.234    60693.234    869.88583    869.88583 
Loop time of 194.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.970 hours/ns, 5.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 193.35     | 193.35     | 193.35     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15202    | 0.15202    | 0.15202    |   0.0 |  0.08
Output  | 0.00017594 | 0.00017594 | 0.00017594 |   0.0 |  0.00
Modify  | 0.69098    | 0.69098    | 0.69098    |   0.0 |  0.36
Other   |            | 0.09691    |            |       |  0.05

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

Total # of neighbors = 311916
Ave neighs/atom = 77.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.428929934402, Press = -0.371119246506123
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -22757.989   -22757.989   -22920.375   -22920.375    314.14522    314.14522    60693.234    60693.234    869.88583    869.88583 
   95000   -22763.039   -22763.039   -22922.514   -22922.514     308.5163     308.5163    60709.547    60709.547    258.05638    258.05638 
Loop time of 192.424 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.49     | 191.49     | 191.49     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15171    | 0.15171    | 0.15171    |   0.0 |  0.08
Output  | 0.00017851 | 0.00017851 | 0.00017851 |   0.0 |  0.00
Modify  | 0.68286    | 0.68286    | 0.68286    |   0.0 |  0.35
Other   |            | 0.0974     |            |       |  0.05

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

Total # of neighbors = 311902
Ave neighs/atom = 77.975500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.410788385518, Press = -0.494132589707044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -22763.039   -22763.039   -22922.514   -22922.514     308.5163     308.5163    60709.547    60709.547    258.05638    258.05638 
   96000   -22755.797   -22755.797   -22918.426   -22918.426    314.61634    314.61634    60748.754    60748.754   -512.71829   -512.71829 
Loop time of 192.127 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 191.2      | 191.2      | 191.2      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15043    | 0.15043    | 0.15043    |   0.0 |  0.08
Output  | 0.00017757 | 0.00017757 | 0.00017757 |   0.0 |  0.00
Modify  | 0.68027    | 0.68027    | 0.68027    |   0.0 |  0.35
Other   |            | 0.09654    |            |       |  0.05

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

Total # of neighbors = 311868
Ave neighs/atom = 77.967000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.401963372955, Press = -0.390542765405628
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -22755.797   -22755.797   -22918.426   -22918.426    314.61634    314.61634    60748.754    60748.754   -512.71829   -512.71829 
   97000   -22762.618   -22762.618   -22923.073   -22923.073    310.41126    310.41126    60740.816    60740.816   -631.89372   -631.89372 
Loop time of 199.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.501 hours/ns, 5.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    | 198.83     | 198.83     | 198.83     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15587    | 0.15587    | 0.15587    |   0.0 |  0.08
Output  | 0.00017825 | 0.00017825 | 0.00017825 |   0.0 |  0.00
Modify  | 0.71861    | 0.71861    | 0.71861    |   0.0 |  0.36
Other   |            | 0.09915    |            |       |  0.05

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

Total # of neighbors = 311896
Ave neighs/atom = 77.974000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.394583174238, Press = -0.246162796406108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -22762.618   -22762.618   -22923.073   -22923.073    310.41126    310.41126    60740.816    60740.816   -631.89372   -631.89372 
   98000   -22758.931   -22758.931   -22919.044   -22919.044    309.75019    309.75019    60751.393    60751.393   -767.59641   -767.59641 
Loop time of 195.039 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.178 hours/ns, 5.127 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.1      | 194.1      | 194.1      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15349    | 0.15349    | 0.15349    |   0.0 |  0.08
Output  | 0.00018019 | 0.00018019 | 0.00018019 |   0.0 |  0.00
Modify  | 0.69312    | 0.69312    | 0.69312    |   0.0 |  0.36
Other   |            | 0.09667    |            |       |  0.05

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

Total # of neighbors = 311888
Ave neighs/atom = 77.972000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.391084267363, Press = -0.0831323173573604
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -22758.931   -22758.931   -22919.044   -22919.044    309.75019    309.75019    60751.393    60751.393   -767.59641   -767.59641 
   99000   -22760.592   -22760.592   -22920.609   -22920.609     309.5641     309.5641    60727.082    60727.082   -122.78341   -122.78341 
Loop time of 198.086 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.024 hours/ns, 5.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.12     | 197.12     | 197.12     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15526    | 0.15526    | 0.15526    |   0.0 |  0.08
Output  | 0.00017707 | 0.00017707 | 0.00017707 |   0.0 |  0.00
Modify  | 0.71157    | 0.71157    | 0.71157    |   0.0 |  0.36
Other   |            | 0.09706    |            |       |  0.05

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

Total # of neighbors = 311878
Ave neighs/atom = 77.969500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.373959356092, Press = 0.276648878575409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -22760.592   -22760.592   -22920.609   -22920.609     309.5641     309.5641    60727.082    60727.082   -122.78341   -122.78341 
  100000   -22763.471   -22763.471   -22922.898   -22922.898    308.42327    308.42327    60653.685    60653.685    1898.7908    1898.7908 
Loop time of 195.314 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.254 hours/ns, 5.120 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.37     | 194.37     | 194.37     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15207    | 0.15207    | 0.15207    |   0.0 |  0.08
Output  | 0.00017741 | 0.00017741 | 0.00017741 |   0.0 |  0.00
Modify  | 0.69625    | 0.69625    | 0.69625    |   0.0 |  0.36
Other   |            | 0.09742    |            |       |  0.05

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

Total # of neighbors = 311926
Ave neighs/atom = 77.981500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.362418098647, Press = 0.310735392903853
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -22763.471   -22763.471   -22922.898   -22922.898    308.42327    308.42327    60653.685    60653.685    1898.7908    1898.7908 
  101000   -22761.802   -22761.802   -22921.346   -22921.346     308.6498     308.6498    60686.031    60686.031    1061.2316    1061.2316 
Loop time of 195.225 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.229 hours/ns, 5.122 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.28     | 194.28     | 194.28     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1529     | 0.1529     | 0.1529     |   0.0 |  0.08
Output  | 0.00017948 | 0.00017948 | 0.00017948 |   0.0 |  0.00
Modify  | 0.69573    | 0.69573    | 0.69573    |   0.0 |  0.36
Other   |            | 0.09724    |            |       |  0.05

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

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.353482435562, Press = -0.231379906815137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -22761.802   -22761.802   -22921.346   -22921.346     308.6498     308.6498    60686.031    60686.031    1061.2316    1061.2316 
  102000   -22758.039   -22758.039   -22919.096   -22919.096    311.57651    311.57651    60717.536    60717.536    245.59682    245.59682 
Loop time of 196.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.631 hours/ns, 5.085 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.72     | 195.72     | 195.72     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15314    | 0.15314    | 0.15314    |   0.0 |  0.08
Output  | 0.00023575 | 0.00023575 | 0.00023575 |   0.0 |  0.00
Modify  | 0.69922    | 0.69922    | 0.69922    |   0.0 |  0.36
Other   |            | 0.09769    |            |       |  0.05

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

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.359597699301, Press = -0.311320748262284
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -22758.039   -22758.039   -22919.096   -22919.096    311.57651    311.57651    60717.536    60717.536    245.59682    245.59682 
  103000   -22762.623   -22762.623   -22921.618   -22921.618    307.58642    307.58642    60720.037    60720.037   -50.344005   -50.344005 
Loop time of 193.011 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.614 hours/ns, 5.181 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 192.08     | 192.08     | 192.08     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15113    | 0.15113    | 0.15113    |   0.0 |  0.08
Output  | 0.00017796 | 0.00017796 | 0.00017796 |   0.0 |  0.00
Modify  | 0.68676    | 0.68676    | 0.68676    |   0.0 |  0.36
Other   |            | 0.0962     |            |       |  0.05

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

Total # of neighbors = 311904
Ave neighs/atom = 77.976000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.343877865996, Press = -0.229775495673031
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -22762.623   -22762.623   -22921.618   -22921.618    307.58642    307.58642    60720.037    60720.037   -50.344005   -50.344005 
  104000    -22761.16    -22761.16   -22922.523   -22922.523    312.16644    312.16644    60766.499    60766.499    -1431.182    -1431.182 
Loop time of 200.222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.617 hours/ns, 4.994 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.24     | 199.24     | 199.24     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15663    | 0.15663    | 0.15663    |   0.0 |  0.08
Output  | 0.00017982 | 0.00017982 | 0.00017982 |   0.0 |  0.00
Modify  | 0.72242    | 0.72242    | 0.72242    |   0.0 |  0.36
Other   |            | 0.09858    |            |       |  0.05

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

Total # of neighbors = 311896
Ave neighs/atom = 77.974000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.331685815598, Press = -0.341969300063596
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000    -22761.16    -22761.16   -22922.523   -22922.523    312.16644    312.16644    60766.499    60766.499    -1431.182    -1431.182 
  105000    -22758.05    -22758.05   -22918.957   -22918.957    311.28394    311.28394     60782.31     60782.31   -1587.4994   -1587.4994 
Loop time of 196.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.626 hours/ns, 5.085 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.7      | 195.7      | 195.7      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15502    | 0.15502    | 0.15502    |   0.0 |  0.08
Output  | 0.00029578 | 0.00029578 | 0.00029578 |   0.0 |  0.00
Modify  | 0.70587    | 0.70587    | 0.70587    |   0.0 |  0.36
Other   |            | 0.09694    |            |       |  0.05

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

Total # of neighbors = 311900
Ave neighs/atom = 77.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
60724.9690596623

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0