# 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.1465589627623562*${_u_distance}
variable latticeconst_converted equal 3.1465589627623562*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.14655896276236
Lattice spacing in x,y,z = 3.1465590 3.1465590 3.1465590
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 (31.465590 31.465590 31.465590)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (31.465590 31.465590 31.465590)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Mo

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

kim interactions Mo
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WangOhLee_2020_CuMo__MO_486450342170_001
pair_coeff * * Mo
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 95.94

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31153.5557782513 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_486450342170_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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13533.917   -13533.917       -13620       -13620       333.15       333.15    31153.556    31153.556    2951.4147    2951.4147 
    1000   -13444.991   -13444.991   -13540.897   -13540.897    371.16625    371.16625    31332.638    31332.638   -742.81892   -742.81892 
Loop time of 117.456 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.736 ns/day, 32.627 hours/ns, 8.514 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.95     | 116.95     | 116.95     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099943   | 0.099943   | 0.099943   |   0.0 |  0.09
Output  | 0.00020119 | 0.00020119 | 0.00020119 |   0.0 |  0.00
Modify  | 0.35052    | 0.35052    | 0.35052    |   0.0 |  0.30
Other   |            | 0.05935    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13444.991   -13444.991   -13540.897   -13540.897    371.16625    371.16625    31332.638    31332.638   -742.81892   -742.81892 
    2000   -13444.169   -13444.169   -13528.094   -13528.094    324.79657    324.79657    31347.529    31347.529   -337.97722   -337.97722 
Loop time of 119.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.214 hours/ns, 8.363 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.08     | 119.08     | 119.08     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098729   | 0.098729   | 0.098729   |   0.0 |  0.08
Output  | 0.00019375 | 0.00019375 | 0.00019375 |   0.0 |  0.00
Modify  | 0.336      | 0.336      | 0.336      |   0.0 |  0.28
Other   |            | 0.05841    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      133956.0 ave      133956 max      133956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133956
Ave neighs/atom = 66.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 = 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13444.169   -13444.169   -13528.094   -13528.094    324.79657    324.79657    31347.529    31347.529   -337.97722   -337.97722 
    3000   -13447.557   -13447.557   -13531.478   -13531.478    324.78104    324.78104    31331.627    31331.627    389.52342    389.52342 
Loop time of 131.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.483 hours/ns, 7.614 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.79     | 130.79     | 130.79     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10417    | 0.10417    | 0.10417    |   0.0 |  0.08
Output  | 0.00028613 | 0.00028613 | 0.00028613 |   0.0 |  0.00
Modify  | 0.38346    | 0.38346    | 0.38346    |   0.0 |  0.29
Other   |            | 0.06262    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134734.0 ave      134734 max      134734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134734
Ave neighs/atom = 67.367000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13447.557   -13447.557   -13531.478   -13531.478    324.78104    324.78104    31331.627    31331.627    389.52342    389.52342 
    4000     -13442.6     -13442.6   -13536.528   -13536.528    363.51334    363.51334    31298.596    31298.596    2763.1684    2763.1684 
Loop time of 140.037 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.899 hours/ns, 7.141 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.44     | 139.44     | 139.44     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10953    | 0.10953    | 0.10953    |   0.0 |  0.08
Output  | 0.00018985 | 0.00018985 | 0.00018985 |   0.0 |  0.00
Modify  | 0.41922    | 0.41922    | 0.41922    |   0.0 |  0.30
Other   |            | 0.06637    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134882.0 ave      134882 max      134882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134882
Ave neighs/atom = 67.441000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000     -13442.6     -13442.6   -13536.528   -13536.528    363.51334    363.51334    31298.596    31298.596    2763.1684    2763.1684 
    5000    -13447.32    -13447.32   -13533.967   -13533.967    335.33108    335.33108    31295.136    31295.136    3087.3907    3087.3907 
Loop time of 138.586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.623 ns/day, 38.496 hours/ns, 7.216 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.99     | 137.99     | 137.99     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10812    | 0.10812    | 0.10812    |   0.0 |  0.08
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.41698    | 0.41698    | 0.41698    |   0.0 |  0.30
Other   |            | 0.066      |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134884.0 ave      134884 max      134884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134884
Ave neighs/atom = 67.442000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.257473727159, Press = -225.196677344385
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -13447.32    -13447.32   -13533.967   -13533.967    335.33108    335.33108    31295.136    31295.136    3087.3907    3087.3907 
    6000   -13442.951   -13442.951   -13527.799   -13527.799    328.37027    328.37027    31343.008    31343.008   -283.08349   -283.08349 
Loop time of 119.773 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.270 hours/ns, 8.349 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.27     | 119.27     | 119.27     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095621   | 0.095621   | 0.095621   |   0.0 |  0.08
Output  | 0.00015708 | 0.00015708 | 0.00015708 |   0.0 |  0.00
Modify  | 0.35098    | 0.35098    | 0.35098    |   0.0 |  0.29
Other   |            | 0.05907    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135282.0 ave      135282 max      135282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135282
Ave neighs/atom = 67.641000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.549735119575, Press = -38.1335424666834
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13442.951   -13442.951   -13527.799   -13527.799    328.37027    328.37027    31343.008    31343.008   -283.08349   -283.08349 
    7000   -13446.343   -13446.343   -13533.061   -13533.061    335.60798    335.60798    31344.311    31344.311   -812.74772   -812.74772 
Loop time of 126.007 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 35.002 hours/ns, 7.936 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.47     | 125.47     | 125.47     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10039    | 0.10039    | 0.10039    |   0.0 |  0.08
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.37876    | 0.37876    | 0.37876    |   0.0 |  0.30
Other   |            | 0.0608     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135148.0 ave      135148 max      135148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135148
Ave neighs/atom = 67.574000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.602116463723, Press = -35.7099852807736
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13446.343   -13446.343   -13533.061   -13533.061    335.60798    335.60798    31344.311    31344.311   -812.74772   -812.74772 
    8000   -13442.979   -13442.979   -13532.461   -13532.461    346.30535    346.30535    31336.043    31336.043   -63.736908   -63.736908 
Loop time of 138.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.623 ns/day, 38.515 hours/ns, 7.212 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.04     | 138.04     | 138.04     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11038    | 0.11038    | 0.11038    |   0.0 |  0.08
Output  | 0.00015608 | 0.00015608 | 0.00015608 |   0.0 |  0.00
Modify  | 0.43808    | 0.43808    | 0.43808    |   0.0 |  0.32
Other   |            | 0.06456    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134680.0 ave      134680 max      134680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134680
Ave neighs/atom = 67.340000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.55426571925, Press = -32.0894048726051
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13442.979   -13442.979   -13532.461   -13532.461    346.30535    346.30535    31336.043    31336.043   -63.736908   -63.736908 
    9000   -13444.122   -13444.122   -13533.776   -13533.776    346.97024    346.97024    31309.456    31309.456    2016.1285    2016.1285 
Loop time of 136.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.631 ns/day, 38.038 hours/ns, 7.303 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.32     | 136.32     | 136.32     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11108    | 0.11108    | 0.11108    |   0.0 |  0.08
Output  | 0.00015849 | 0.00015849 | 0.00015849 |   0.0 |  0.00
Modify  | 0.43835    | 0.43835    | 0.43835    |   0.0 |  0.32
Other   |            | 0.06385    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134660.0 ave      134660 max      134660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134660
Ave neighs/atom = 67.330000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.934087217981, Press = -22.5793765894224
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13444.122   -13444.122   -13533.776   -13533.776    346.97024    346.97024    31309.456    31309.456    2016.1285    2016.1285 
   10000   -13449.971   -13449.971   -13536.432   -13536.432    334.61171    334.61171    31277.901    31277.901    4192.4029    4192.4029 
Loop time of 127.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.391 hours/ns, 7.849 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.85     | 126.85     | 126.85     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10323    | 0.10323    | 0.10323    |   0.0 |  0.08
Output  | 0.00015645 | 0.00015645 | 0.00015645 |   0.0 |  0.00
Modify  | 0.39148    | 0.39148    | 0.39148    |   0.0 |  0.31
Other   |            | 0.06157    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135000.0 ave      135000 max      135000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135000
Ave neighs/atom = 67.500000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.27651548817, Press = 5.08468655725478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13449.971   -13449.971   -13536.432   -13536.432    334.61171    334.61171    31277.901    31277.901    4192.4029    4192.4029 
   11000   -13443.973   -13443.973   -13531.875   -13531.875    340.18961    340.18961    31365.864    31365.864   -2618.9753   -2618.9753 
Loop time of 119.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.182 hours/ns, 8.371 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.95     | 118.95     | 118.95     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096097   | 0.096097   | 0.096097   |   0.0 |  0.08
Output  | 0.00015557 | 0.00015557 | 0.00015557 |   0.0 |  0.00
Modify  | 0.35266    | 0.35266    | 0.35266    |   0.0 |  0.30
Other   |            | 0.06001    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135138.0 ave      135138 max      135138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135138
Ave neighs/atom = 67.569000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.982127357444, Press = 3.29673416450164
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13443.973   -13443.973   -13531.875   -13531.875    340.18961    340.18961    31365.864    31365.864   -2618.9753   -2618.9753 
   12000   -13447.222   -13447.222   -13531.996   -13531.996    328.08402    328.08402    31356.359    31356.359   -1842.7744   -1842.7744 
Loop time of 125.261 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.690 ns/day, 34.795 hours/ns, 7.983 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.72     | 124.72     | 124.72     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098496   | 0.098496   | 0.098496   |   0.0 |  0.08
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.37748    | 0.37748    | 0.37748    |   0.0 |  0.30
Other   |            | 0.06279    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134564.0 ave      134564 max      134564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134564
Ave neighs/atom = 67.282000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.692422075955, Press = -10.1035181044651
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13447.222   -13447.222   -13531.996   -13531.996    328.08402    328.08402    31356.359    31356.359   -1842.7744   -1842.7744 
   13000   -13447.615   -13447.615   -13532.661   -13532.661    329.13857    329.13857    31335.015    31335.015    -301.9549    -301.9549 
Loop time of 128.122 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.590 hours/ns, 7.805 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    | 127.57     | 127.57     | 127.57     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10229    | 0.10229    | 0.10229    |   0.0 |  0.08
Output  | 0.00015695 | 0.00015695 | 0.00015695 |   0.0 |  0.00
Modify  | 0.38936    | 0.38936    | 0.38936    |   0.0 |  0.30
Other   |            | 0.06279    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134564.0 ave      134564 max      134564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134564
Ave neighs/atom = 67.282000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.769357772447, Press = -10.7771302939947
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13447.615   -13447.615   -13532.661   -13532.661    329.13857    329.13857    31335.015    31335.015    -301.9549    -301.9549 
   14000   -13440.852   -13440.852   -13528.173   -13528.173    337.93979    337.93979     31319.87     31319.87    1777.2186    1777.2186 
Loop time of 132.666 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.852 hours/ns, 7.538 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    | 132.08     | 132.08     | 132.08     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10603    | 0.10603    | 0.10603    |   0.0 |  0.08
Output  | 0.00015697 | 0.00015697 | 0.00015697 |   0.0 |  0.00
Modify  | 0.41124    | 0.41124    | 0.41124    |   0.0 |  0.31
Other   |            | 0.0647     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134824.0 ave      134824 max      134824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134824
Ave neighs/atom = 67.412000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.13253308421, Press = -8.33841428631373
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13440.852   -13440.852   -13528.173   -13528.173    337.93979    337.93979     31319.87     31319.87    1777.2186    1777.2186 
   15000   -13445.155   -13445.155   -13532.298   -13532.298    337.25192    337.25192     31306.02     31306.02    2377.0941    2377.0941 
Loop time of 133.863 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.184 hours/ns, 7.470 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    | 133.28     | 133.28     | 133.28     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1055     | 0.1055     | 0.1055     |   0.0 |  0.08
Output  | 0.00045782 | 0.00045782 | 0.00045782 |   0.0 |  0.00
Modify  | 0.4136     | 0.4136     | 0.4136     |   0.0 |  0.31
Other   |            | 0.06461    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135380.0 ave      135380 max      135380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135380
Ave neighs/atom = 67.690000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.21564248142, Press = -1.56099849786772
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13445.155   -13445.155   -13532.298   -13532.298    337.25192    337.25192     31306.02     31306.02    2377.0941    2377.0941 
   16000   -13446.934   -13446.934   -13532.481   -13532.481    331.07364    331.07364     31357.91     31357.91   -1974.0632   -1974.0632 
Loop time of 138.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.626 ns/day, 38.368 hours/ns, 7.240 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.51     | 137.51     | 137.51     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11204    | 0.11204    | 0.11204    |   0.0 |  0.08
Output  | 0.00015369 | 0.00015369 | 0.00015369 |   0.0 |  0.00
Modify  | 0.44219    | 0.44219    | 0.44219    |   0.0 |  0.32
Other   |            | 0.06494    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135080.0 ave      135080 max      135080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135080
Ave neighs/atom = 67.540000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.204208207623, Press = 0.303021597291701
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13446.934   -13446.934   -13532.481   -13532.481    331.07364    331.07364     31357.91     31357.91   -1974.0632   -1974.0632 
   17000   -13443.498   -13443.498   -13529.321   -13529.321    332.14277    332.14277    31371.969    31371.969   -2805.2869   -2805.2869 
Loop time of 126.749 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.208 hours/ns, 7.890 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.2      | 126.2      | 126.2      |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10205    | 0.10205    | 0.10205    |   0.0 |  0.08
Output  | 0.00020057 | 0.00020057 | 0.00020057 |   0.0 |  0.00
Modify  | 0.38695    | 0.38695    | 0.38695    |   0.0 |  0.31
Other   |            | 0.06187    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134472.0 ave      134472 max      134472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134472
Ave neighs/atom = 67.236000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.942223342057, Press = -6.04717115451657
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13443.498   -13443.498   -13529.321   -13529.321    332.14277    332.14277    31371.969    31371.969   -2805.2869   -2805.2869 
   18000   -13446.708   -13446.708   -13533.186   -13533.186    334.67735    334.67735    31337.937    31337.937   -501.85429   -501.85429 
Loop time of 139.505 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.751 hours/ns, 7.168 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.88     | 138.88     | 138.88     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10971    | 0.10971    | 0.10971    |   0.0 |  0.08
Output  | 0.00024765 | 0.00024765 | 0.00024765 |   0.0 |  0.00
Modify  | 0.445      | 0.445      | 0.445      |   0.0 |  0.32
Other   |            | 0.06656    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134578.0 ave      134578 max      134578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134578
Ave neighs/atom = 67.289000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.983844144455, Press = -6.28073229875472
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13446.708   -13446.708   -13533.186   -13533.186    334.67735    334.67735    31337.937    31337.937   -501.85429   -501.85429 
   19000   -13443.661   -13443.661   -13531.521   -13531.521    340.02853    340.02853    31328.697    31328.697    743.19907    743.19907 
Loop time of 139.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.709 hours/ns, 7.176 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    | 138.73     | 138.73     | 138.73     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11027    | 0.11027    | 0.11027    |   0.0 |  0.08
Output  | 0.00024729 | 0.00024729 | 0.00024729 |   0.0 |  0.00
Modify  | 0.441      | 0.441      | 0.441      |   0.0 |  0.32
Other   |            | 0.06702    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134862.0 ave      134862 max      134862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134862
Ave neighs/atom = 67.431000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.168122001239, Press = -4.29035485017761
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13443.661   -13443.661   -13531.521   -13531.521    340.02853    340.02853    31328.697    31328.697    743.19907    743.19907 
   20000   -13445.756   -13445.756   -13531.539   -13531.539    331.98908    331.98908    31323.718    31323.718    1019.5086    1019.5086 
Loop time of 138.137 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.625 ns/day, 38.371 hours/ns, 7.239 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.52     | 137.52     | 137.52     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1129     | 0.1129     | 0.1129     |   0.0 |  0.08
Output  | 0.00015626 | 0.00015626 | 0.00015626 |   0.0 |  0.00
Modify  | 0.44249    | 0.44249    | 0.44249    |   0.0 |  0.32
Other   |            | 0.06456    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135052.0 ave      135052 max      135052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135052
Ave neighs/atom = 67.526000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.362168629469, Press = -2.3191462512139
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13445.756   -13445.756   -13531.539   -13531.539    331.98908    331.98908    31323.718    31323.718    1019.5086    1019.5086 
   21000    -13442.88    -13442.88   -13529.321   -13529.321    334.53528    334.53528    31355.216    31355.216   -1407.1597   -1407.1597 
Loop time of 122.112 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.920 hours/ns, 8.189 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.59     | 121.59     | 121.59     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097624   | 0.097624   | 0.097624   |   0.0 |  0.08
Output  | 0.00015407 | 0.00015407 | 0.00015407 |   0.0 |  0.00
Modify  | 0.36523    | 0.36523    | 0.36523    |   0.0 |  0.30
Other   |            | 0.06103    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135064.0 ave      135064 max      135064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135064
Ave neighs/atom = 67.532000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.383252622422, Press = -1.61119253907339
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    -13442.88    -13442.88   -13529.321   -13529.321    334.53528    334.53528    31355.216    31355.216   -1407.1597   -1407.1597 
   22000   -13447.175   -13447.175   -13532.511   -13532.511    330.26016    330.26016    31367.576    31367.576   -2894.1136   -2894.1136 
Loop time of 139.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.617 hours/ns, 7.193 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    | 138.41     | 138.41     | 138.41     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.08
Output  | 0.00015513 | 0.00015513 | 0.00015513 |   0.0 |  0.00
Modify  | 0.43971    | 0.43971    | 0.43971    |   0.0 |  0.32
Other   |            | 0.06586    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134850.0 ave      134850 max      134850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134850
Ave neighs/atom = 67.425000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.228354261804, Press = -5.46446971760267
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13447.175   -13447.175   -13532.511   -13532.511    330.26016    330.26016    31367.576    31367.576   -2894.1136   -2894.1136 
   23000   -13443.261   -13443.261   -13533.059   -13533.059    347.52676    347.52676    31335.465    31335.465   -12.421202   -12.421202 
Loop time of 139.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.641 hours/ns, 7.189 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.49     | 138.49     | 138.49     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10869    | 0.10869    | 0.10869    |   0.0 |  0.08
Output  | 0.00019046 | 0.00019046 | 0.00019046 |   0.0 |  0.00
Modify  | 0.43984    | 0.43984    | 0.43984    |   0.0 |  0.32
Other   |            | 0.06576    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134344.0 ave      134344 max      134344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134344
Ave neighs/atom = 67.172000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.152998865235, Press = -6.82398566853133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13443.261   -13443.261   -13533.059   -13533.059    347.52676    347.52676    31335.465    31335.465   -12.421202   -12.421202 
   24000   -13445.092   -13445.092   -13531.342   -13531.342    333.79378    333.79378    31297.952    31297.952    3292.1742    3292.1742 
Loop time of 139.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.716 hours/ns, 7.175 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.77     | 138.77     | 138.77     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10911    | 0.10911    | 0.10911    |   0.0 |  0.08
Output  | 0.00015303 | 0.00015303 | 0.00015303 |   0.0 |  0.00
Modify  | 0.4374     | 0.4374     | 0.4374     |   0.0 |  0.31
Other   |            | 0.06633    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134684.0 ave      134684 max      134684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134684
Ave neighs/atom = 67.342000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.152588396375, Press = -3.46868132675865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13445.092   -13445.092   -13531.342   -13531.342    333.79378    333.79378    31297.952    31297.952    3292.1742    3292.1742 
   25000   -13446.921   -13446.921   -13532.865   -13532.865    332.61253    332.61253    31310.227    31310.227    2003.4526    2003.4526 
Loop time of 139.587 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.774 hours/ns, 7.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    | 138.97     | 138.97     | 138.97     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10932    | 0.10932    | 0.10932    |   0.0 |  0.08
Output  | 0.00021553 | 0.00021553 | 0.00021553 |   0.0 |  0.00
Modify  | 0.44092    | 0.44092    | 0.44092    |   0.0 |  0.32
Other   |            | 0.066      |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135238.0 ave      135238 max      135238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135238
Ave neighs/atom = 67.619000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.314726527578, Press = -0.490601956014097
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13446.921   -13446.921   -13532.865   -13532.865    332.61253    332.61253    31310.227    31310.227    2003.4526    2003.4526 
   26000   -13442.376   -13442.376   -13530.051   -13530.051     339.3112     339.3112    31356.283    31356.283   -1477.5389   -1477.5389 
Loop time of 139.288 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.691 hours/ns, 7.179 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.67     | 138.67     | 138.67     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10965    | 0.10965    | 0.10965    |   0.0 |  0.08
Output  | 0.00020634 | 0.00020634 | 0.00020634 |   0.0 |  0.00
Modify  | 0.43879    | 0.43879    | 0.43879    |   0.0 |  0.32
Other   |            | 0.06594    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134804.0 ave      134804 max      134804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134804
Ave neighs/atom = 67.402000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.352268031486, Press = -1.26889106362847
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13442.376   -13442.376   -13530.051   -13530.051     339.3112     339.3112    31356.283    31356.283   -1477.5389   -1477.5389 
   27000   -13446.282   -13446.282   -13531.316   -13531.316    329.08779    329.08779    31352.746    31352.746    -1386.775    -1386.775 
Loop time of 132.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.739 hours/ns, 7.561 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.68     | 131.68     | 131.68     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10405    | 0.10405    | 0.10405    |   0.0 |  0.08
Output  | 0.00015653 | 0.00015653 | 0.00015653 |   0.0 |  0.00
Modify  | 0.40901    | 0.40901    | 0.40901    |   0.0 |  0.31
Other   |            | 0.06283    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134750.0 ave      134750 max      134750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134750
Ave neighs/atom = 67.375000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.37586013163, Press = -3.84537532246414
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13446.282   -13446.282   -13531.316   -13531.316    329.08779    329.08779    31352.746    31352.746    -1386.775    -1386.775 
   28000   -13444.988   -13444.988   -13532.405   -13532.405    338.30937    338.30937    31333.411    31333.411    187.17055    187.17055 
Loop time of 119.753 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.265 hours/ns, 8.350 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.25     | 119.25     | 119.25     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095952   | 0.095952   | 0.095952   |   0.0 |  0.08
Output  | 0.00019364 | 0.00019364 | 0.00019364 |   0.0 |  0.00
Modify  | 0.35062    | 0.35062    | 0.35062    |   0.0 |  0.29
Other   |            | 0.05873    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134544.0 ave      134544 max      134544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134544
Ave neighs/atom = 67.272000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.387126575141, Press = -3.50654403334035
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13444.988   -13444.988   -13532.405   -13532.405    338.30937    338.30937    31333.411    31333.411    187.17055    187.17055 
   29000   -13446.413   -13446.413   -13530.511   -13530.511    325.46593    325.46593    31323.928    31323.928    998.50185    998.50185 
Loop time of 119.879 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.300 hours/ns, 8.342 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.37     | 119.37     | 119.37     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096559   | 0.096559   | 0.096559   |   0.0 |  0.08
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.35359    | 0.35359    | 0.35359    |   0.0 |  0.29
Other   |            | 0.05884    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134820.0 ave      134820 max      134820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134820
Ave neighs/atom = 67.410000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.257174808846, Press = -2.54176552240852
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13446.413   -13446.413   -13530.511   -13530.511    325.46593    325.46593    31323.928    31323.928    998.50185    998.50185 
   30000   -13445.019   -13445.019   -13528.908   -13528.908     324.6609     324.6609    31327.273    31327.273    1044.4387    1044.4387 
Loop time of 119.932 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.720 ns/day, 33.314 hours/ns, 8.338 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.43     | 119.43     | 119.43     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095651   | 0.095651   | 0.095651   |   0.0 |  0.08
Output  | 0.00019057 | 0.00019057 | 0.00019057 |   0.0 |  0.00
Modify  | 0.35173    | 0.35173    | 0.35173    |   0.0 |  0.29
Other   |            | 0.05859    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135156.0 ave      135156 max      135156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135156
Ave neighs/atom = 67.578000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.178862476028, Press = -2.1344260308608
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13445.019   -13445.019   -13528.908   -13528.908     324.6609     324.6609    31327.273    31327.273    1044.4387    1044.4387 
   31000   -13445.855   -13445.855   -13532.052   -13532.052    333.59231    333.59231    31334.707    31334.707    65.409205    65.409205 
Loop time of 119.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.256 hours/ns, 8.353 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.22     | 119.22     | 119.22     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095428   | 0.095428   | 0.095428   |   0.0 |  0.08
Output  | 0.0001938  | 0.0001938  | 0.0001938  |   0.0 |  0.00
Modify  | 0.35038    | 0.35038    | 0.35038    |   0.0 |  0.29
Other   |            | 0.05878    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135174.0 ave      135174 max      135174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135174
Ave neighs/atom = 67.587000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.15806142919, Press = -2.66345505294151
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13445.855   -13445.855   -13532.052   -13532.052    333.59231    333.59231    31334.707    31334.707    65.409205    65.409205 
   32000   -13441.751   -13441.751   -13529.755   -13529.755    340.58652    340.58652    31339.139    31339.139   -28.467175   -28.467175 
Loop time of 119.426 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.174 hours/ns, 8.373 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.92     | 118.92     | 118.92     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095207   | 0.095207   | 0.095207   |   0.0 |  0.08
Output  | 0.00015758 | 0.00015758 | 0.00015758 |   0.0 |  0.00
Modify  | 0.35055    | 0.35055    | 0.35055    |   0.0 |  0.29
Other   |            | 0.0581     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134596.0 ave      134596 max      134596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134596
Ave neighs/atom = 67.298000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.248740529528, Press = -2.5394184479377
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13441.751   -13441.751   -13529.755   -13529.755    340.58652    340.58652    31339.139    31339.139   -28.467175   -28.467175 
   33000   -13446.204   -13446.204   -13530.734   -13530.734    327.13684    327.13684    31334.103    31334.103    92.939659    92.939659 
Loop time of 119.473 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.187 hours/ns, 8.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.97     | 118.97     | 118.97     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09512    | 0.09512    | 0.09512    |   0.0 |  0.08
Output  | 0.00015661 | 0.00015661 | 0.00015661 |   0.0 |  0.00
Modify  | 0.35069    | 0.35069    | 0.35069    |   0.0 |  0.29
Other   |            | 0.05862    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134958.0 ave      134958 max      134958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134958
Ave neighs/atom = 67.479000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.319534379429, Press = -2.66577389504015
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13446.204   -13446.204   -13530.734   -13530.734    327.13684    327.13684    31334.103    31334.103    92.939659    92.939659 
   34000   -13437.345   -13437.345   -13527.269   -13527.269    348.01612    348.01612    31342.697    31342.697    171.70228    171.70228 
Loop time of 139.532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.759 hours/ns, 7.167 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.91     | 138.91     | 138.91     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11027    | 0.11027    | 0.11027    |   0.0 |  0.08
Output  | 0.00015589 | 0.00015589 | 0.00015589 |   0.0 |  0.00
Modify  | 0.44236    | 0.44236    | 0.44236    |   0.0 |  0.32
Other   |            | 0.06699    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134948.0 ave      134948 max      134948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134948
Ave neighs/atom = 67.474000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.401605385559, Press = -2.54377758901719
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13437.345   -13437.345   -13527.269   -13527.269    348.01612    348.01612    31342.697    31342.697    171.70228    171.70228 
   35000   -13445.702   -13445.702   -13531.344   -13531.344    331.44504    331.44504    31330.688    31330.688    243.83831    243.83831 
Loop time of 139.156 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.654 hours/ns, 7.186 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.54     | 138.54     | 138.54     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10927    | 0.10927    | 0.10927    |   0.0 |  0.08
Output  | 0.00015312 | 0.00015312 | 0.00015312 |   0.0 |  0.00
Modify  | 0.44026    | 0.44026    | 0.44026    |   0.0 |  0.32
Other   |            | 0.06583    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134964.0 ave      134964 max      134964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134964
Ave neighs/atom = 67.482000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.476381961186, Press = -2.10622175850489
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13445.702   -13445.702   -13531.344   -13531.344    331.44504    331.44504    31330.688    31330.688    243.83831    243.83831 
   36000   -13441.367   -13441.367   -13528.655   -13528.655    337.81255    337.81255    31340.318    31340.318   -79.768137   -79.768137 
Loop time of 121.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.809 hours/ns, 8.216 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.19     | 121.19     | 121.19     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095744   | 0.095744   | 0.095744   |   0.0 |  0.08
Output  | 0.00019256 | 0.00019256 | 0.00019256 |   0.0 |  0.00
Modify  | 0.36091    | 0.36091    | 0.36091    |   0.0 |  0.30
Other   |            | 0.06122    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134818.0 ave      134818 max      134818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134818
Ave neighs/atom = 67.409000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.52723022169, Press = -2.03629048710889
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13441.367   -13441.367   -13528.655   -13528.655    337.81255    337.81255    31340.318    31340.318   -79.768137   -79.768137 
   37000   -13445.954   -13445.954    -13532.26    -13532.26     334.0151     334.0151    31346.699    31346.699   -1121.1832   -1121.1832 
Loop time of 138.288 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.625 ns/day, 38.413 hours/ns, 7.231 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.68     | 137.68     | 137.68     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10855    | 0.10855    | 0.10855    |   0.0 |  0.08
Output  | 0.00015538 | 0.00015538 | 0.00015538 |   0.0 |  0.00
Modify  | 0.43387    | 0.43387    | 0.43387    |   0.0 |  0.31
Other   |            | 0.06673    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135056.0 ave      135056 max      135056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135056
Ave neighs/atom = 67.528000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.581792791396, Press = -2.37006951798406
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13445.954   -13445.954    -13532.26    -13532.26     334.0151     334.0151    31346.699    31346.699   -1121.1832   -1121.1832 
   38000   -13444.628   -13444.628   -13531.578   -13531.578    336.50472    336.50472    31352.693    31352.693   -1264.2749   -1264.2749 
Loop time of 122.348 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.706 ns/day, 33.986 hours/ns, 8.173 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.83     | 121.83     | 121.83     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095758   | 0.095758   | 0.095758   |   0.0 |  0.08
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.36332    | 0.36332    | 0.36332    |   0.0 |  0.30
Other   |            | 0.06118    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134748.0 ave      134748 max      134748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134748
Ave neighs/atom = 67.374000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.550140885543, Press = -3.29266217801294
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13444.628   -13444.628   -13531.578   -13531.578    336.50472    336.50472    31352.693    31352.693   -1264.2749   -1264.2749 
   39000   -13445.789   -13445.789   -13531.705   -13531.705    332.50337    332.50337    31309.207    31309.207    2183.5385    2183.5385 
Loop time of 124.501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.584 hours/ns, 8.032 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.97     | 123.97     | 123.97     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098281   | 0.098281   | 0.098281   |   0.0 |  0.08
Output  | 0.00019808 | 0.00019808 | 0.00019808 |   0.0 |  0.00
Modify  | 0.37385    | 0.37385    | 0.37385    |   0.0 |  0.30
Other   |            | 0.06206    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134602.0 ave      134602 max      134602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134602
Ave neighs/atom = 67.301000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.509454808875, Press = -3.85234278996962
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13445.789   -13445.789   -13531.705   -13531.705    332.50337    332.50337    31309.207    31309.207    2183.5385    2183.5385 
   40000   -13446.388   -13446.388   -13532.825   -13532.825    334.52274    334.52274    31295.907    31295.907    3015.5087    3015.5087 
Loop time of 139.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.693 hours/ns, 7.179 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.68     | 138.68     | 138.68     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10965    | 0.10965    | 0.10965    |   0.0 |  0.08
Output  | 0.00023856 | 0.00023856 | 0.00023856 |   0.0 |  0.00
Modify  | 0.43736    | 0.43736    | 0.43736    |   0.0 |  0.31
Other   |            | 0.06645    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135248.0 ave      135248 max      135248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135248
Ave neighs/atom = 67.624000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.416835815376, Press = -1.25512139274949
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13446.388   -13446.388   -13532.825   -13532.825    334.52274    334.52274    31295.907    31295.907    3015.5087    3015.5087 
   41000   -13443.934   -13443.934   -13530.354   -13530.354    334.45526    334.45526    31341.621    31341.621   -250.93785   -250.93785 
Loop time of 139.713 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.809 hours/ns, 7.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    | 139.1      | 139.1      | 139.1      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11011    | 0.11011    | 0.11011    |   0.0 |  0.08
Output  | 0.00050012 | 0.00050012 | 0.00050012 |   0.0 |  0.00
Modify  | 0.43985    | 0.43985    | 0.43985    |   0.0 |  0.31
Other   |            | 0.06632    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135568.0 ave      135568 max      135568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135568
Ave neighs/atom = 67.784000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.396982012488, Press = -1.0484055210205
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13443.934   -13443.934   -13530.354   -13530.354    334.45526    334.45526    31341.621    31341.621   -250.93785   -250.93785 
   42000   -13445.687   -13445.687   -13531.258   -13531.258    331.16975    331.16975    31347.984    31347.984   -973.80677   -973.80677 
Loop time of 139.422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.728 hours/ns, 7.172 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.81     | 138.81     | 138.81     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10921    | 0.10921    | 0.10921    |   0.0 |  0.08
Output  | 0.00019661 | 0.00019661 | 0.00019661 |   0.0 |  0.00
Modify  | 0.43459    | 0.43459    | 0.43459    |   0.0 |  0.31
Other   |            | 0.06553    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134858.0 ave      134858 max      134858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134858
Ave neighs/atom = 67.429000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.311724247277, Press = -2.04224588513975
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13445.687   -13445.687   -13531.258   -13531.258    331.16975    331.16975    31347.984    31347.984   -973.80677   -973.80677 
   43000    -13448.46    -13448.46   -13533.982   -13533.982    330.98191    330.98191     31335.05     31335.05   -403.38005   -403.38005 
Loop time of 139.479 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.744 hours/ns, 7.170 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.87     | 138.87     | 138.87     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10875    | 0.10875    | 0.10875    |   0.0 |  0.08
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.43742    | 0.43742    | 0.43742    |   0.0 |  0.31
Other   |            | 0.06575    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134872.0 ave      134872 max      134872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134872
Ave neighs/atom = 67.436000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.278993753582, Press = -2.32426670855143
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000    -13448.46    -13448.46   -13533.982   -13533.982    330.98191    330.98191     31335.05     31335.05   -403.38005   -403.38005 
   44000    -13444.86    -13444.86   -13531.954   -13531.954    337.06151    337.06151    31332.505    31332.505    191.86329    191.86329 
Loop time of 139.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.855 hours/ns, 7.149 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    | 139.26     | 139.26     | 139.26     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10986    | 0.10986    | 0.10986    |   0.0 |  0.08
Output  | 0.00019797 | 0.00019797 | 0.00019797 |   0.0 |  0.00
Modify  | 0.44297    | 0.44297    | 0.44297    |   0.0 |  0.32
Other   |            | 0.06659    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134738.0 ave      134738 max      134738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134738
Ave neighs/atom = 67.369000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.196506886956, Press = -2.40295265057494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000    -13444.86    -13444.86   -13531.954   -13531.954    337.06151    337.06151    31332.505    31332.505    191.86329    191.86329 
   45000   -13449.038   -13449.038   -13533.516   -13533.516       326.94       326.94    31307.443    31307.443    1982.3592    1982.3592 
Loop time of 140.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.950 hours/ns, 7.132 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.61     | 139.61     | 139.61     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10933    | 0.10933    | 0.10933    |   0.0 |  0.08
Output  | 0.00021502 | 0.00021502 | 0.00021502 |   0.0 |  0.00
Modify  | 0.43779    | 0.43779    | 0.43779    |   0.0 |  0.31
Other   |            | 0.06643    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134780.0 ave      134780 max      134780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134780
Ave neighs/atom = 67.390000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.171789437624, Press = -1.78605770184314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13449.038   -13449.038   -13533.516   -13533.516       326.94       326.94    31307.443    31307.443    1982.3592    1982.3592 
   46000   -13443.947   -13443.947   -13531.075   -13531.075    337.19656    337.19656     31333.42     31333.42    288.91024    288.91024 
Loop time of 140.307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.974 hours/ns, 7.127 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.69     | 139.69     | 139.69     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10996    | 0.10996    | 0.10996    |   0.0 |  0.08
Output  | 0.00021561 | 0.00021561 | 0.00021561 |   0.0 |  0.00
Modify  | 0.44233    | 0.44233    | 0.44233    |   0.0 |  0.32
Other   |            | 0.06643    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135070.0 ave      135070 max      135070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135070
Ave neighs/atom = 67.535000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.100588852815, Press = -0.680651308003281
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13443.947   -13443.947   -13531.075   -13531.075    337.19656    337.19656     31333.42     31333.42    288.91024    288.91024 
   47000   -13446.453   -13446.453   -13532.067   -13532.067    331.33603    331.33603    31371.198    31371.198   -3130.0282   -3130.0282 
Loop time of 129.744 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.040 hours/ns, 7.708 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    | 129.18     | 129.18     | 129.18     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10342    | 0.10342    | 0.10342    |   0.0 |  0.08
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.39852    | 0.39852    | 0.39852    |   0.0 |  0.31
Other   |            | 0.06202    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134868.0 ave      134868 max      134868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134868
Ave neighs/atom = 67.434000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.080309537755, Press = -1.14176147526511
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13446.453   -13446.453   -13532.067   -13532.067    331.33603    331.33603    31371.198    31371.198   -3130.0282   -3130.0282 
   48000    -13443.92    -13443.92   -13530.401   -13530.401    334.69297    334.69297    31360.776    31360.776   -1855.9073   -1855.9073 
Loop time of 123.557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.321 hours/ns, 8.093 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    | 123.03     | 123.03     | 123.03     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099026   | 0.099026   | 0.099026   |   0.0 |  0.08
Output  | 0.00015453 | 0.00015453 | 0.00015453 |   0.0 |  0.00
Modify  | 0.37186    | 0.37186    | 0.37186    |   0.0 |  0.30
Other   |            | 0.05975    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134624.0 ave      134624 max      134624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134624
Ave neighs/atom = 67.312000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.045333893287, Press = -2.63654800640723
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -13443.92    -13443.92   -13530.401   -13530.401    334.69297    334.69297    31360.776    31360.776   -1855.9073   -1855.9073 
   49000   -13452.521   -13452.521   -13534.464   -13534.464    317.12831    317.12831    31318.168    31318.168     794.9191     794.9191 
Loop time of 123.869 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.698 ns/day, 34.408 hours/ns, 8.073 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.34     | 123.34     | 123.34     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099643   | 0.099643   | 0.099643   |   0.0 |  0.08
Output  | 0.00019078 | 0.00019078 | 0.00019078 |   0.0 |  0.00
Modify  | 0.37028    | 0.37028    | 0.37028    |   0.0 |  0.30
Other   |            | 0.06034    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134644.0 ave      134644 max      134644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134644
Ave neighs/atom = 67.322000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.995560521837, Press = -2.25414895903079
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13452.521   -13452.521   -13534.464   -13534.464    317.12831    317.12831    31318.168    31318.168     794.9191     794.9191 
   50000   -13444.768   -13444.768   -13532.301   -13532.301     338.7599     338.7599    31327.368    31327.368    665.51186    665.51186 
Loop time of 119.802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.278 hours/ns, 8.347 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.3      | 119.3      | 119.3      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096349   | 0.096349   | 0.096349   |   0.0 |  0.08
Output  | 0.00015826 | 0.00015826 | 0.00015826 |   0.0 |  0.00
Modify  | 0.35238    | 0.35238    | 0.35238    |   0.0 |  0.29
Other   |            | 0.05799    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134786.0 ave      134786 max      134786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134786
Ave neighs/atom = 67.393000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.948306272295, Press = -1.59931797947562
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13444.768   -13444.768   -13532.301   -13532.301     338.7599     338.7599    31327.368    31327.368    665.51186    665.51186 
   51000   -13447.735   -13447.735   -13534.171   -13534.171    334.51482    334.51482    31329.177    31329.177    182.70047    182.70047 
Loop time of 119.85 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.292 hours/ns, 8.344 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.34     | 119.34     | 119.34     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096278   | 0.096278   | 0.096278   |   0.0 |  0.08
Output  | 0.00015267 | 0.00015267 | 0.00015267 |   0.0 |  0.00
Modify  | 0.3522     | 0.3522     | 0.3522     |   0.0 |  0.29
Other   |            | 0.05863    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134894.0 ave      134894 max      134894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134894
Ave neighs/atom = 67.447000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.904328951162, Press = -1.25245430741354
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13447.735   -13447.735   -13534.171   -13534.171    334.51482    334.51482    31329.177    31329.177    182.70047    182.70047 
   52000   -13442.621   -13442.621   -13527.548   -13527.548    328.67276    328.67276    31353.873    31353.873   -989.53464   -989.53464 
Loop time of 130.311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.198 hours/ns, 7.674 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    | 129.75     | 129.75     | 129.75     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10329    | 0.10329    | 0.10329    |   0.0 |  0.08
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.39805    | 0.39805    | 0.39805    |   0.0 |  0.31
Other   |            | 0.06199    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134686.0 ave      134686 max      134686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134686
Ave neighs/atom = 67.343000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.912254303092, Press = -1.44796556948525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13442.621   -13442.621   -13527.548   -13527.548    328.67276    328.67276    31353.873    31353.873   -989.53464   -989.53464 
   53000   -13446.362   -13446.362   -13529.138   -13529.138    320.35181    320.35181    31360.001    31360.001   -1814.5439   -1814.5439 
Loop time of 139.632 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.787 hours/ns, 7.162 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.02     | 139.02     | 139.02     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11006    | 0.11006    | 0.11006    |   0.0 |  0.08
Output  | 0.00023788 | 0.00023788 | 0.00023788 |   0.0 |  0.00
Modify  | 0.43865    | 0.43865    | 0.43865    |   0.0 |  0.31
Other   |            | 0.06579    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134788.0 ave      134788 max      134788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134788
Ave neighs/atom = 67.394000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.95766698308, Press = -2.71069864682535
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13446.362   -13446.362   -13529.138   -13529.138    320.35181    320.35181    31360.001    31360.001   -1814.5439   -1814.5439 
   54000   -13443.403   -13443.403   -13532.542   -13532.542    344.97647    344.97647    31315.747    31315.747     1490.171     1490.171 
Loop time of 139.908 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.863 hours/ns, 7.148 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.29     | 139.29     | 139.29     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1103     | 0.1103     | 0.1103     |   0.0 |  0.08
Output  | 0.00015538 | 0.00015538 | 0.00015538 |   0.0 |  0.00
Modify  | 0.44123    | 0.44123    | 0.44123    |   0.0 |  0.32
Other   |            | 0.06623    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134730.0 ave      134730 max      134730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134730
Ave neighs/atom = 67.365000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.0289123746, Press = -3.08770593224324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13443.403   -13443.403   -13532.542   -13532.542    344.97647    344.97647    31315.747    31315.747     1490.171     1490.171 
   55000    -13442.88    -13442.88   -13531.541   -13531.541    343.12734    343.12734    31300.933    31300.933     2790.489     2790.489 
Loop time of 140.039 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.900 hours/ns, 7.141 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.42     | 139.42     | 139.42     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10985    | 0.10985    | 0.10985    |   0.0 |  0.08
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.43964    | 0.43964    | 0.43964    |   0.0 |  0.31
Other   |            | 0.06625    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135108.0 ave      135108 max      135108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135108
Ave neighs/atom = 67.554000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.029652331874, Press = -1.44373953359076
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000    -13442.88    -13442.88   -13531.541   -13531.541    343.12734    343.12734    31300.933    31300.933     2790.489     2790.489 
   56000   -13447.469   -13447.469   -13535.153   -13535.153    339.34659    339.34659    31328.862    31328.862    1.4156699    1.4156699 
Loop time of 140.312 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.976 hours/ns, 7.127 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.69     | 139.69     | 139.69     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11067    | 0.11067    | 0.11067    |   0.0 |  0.08
Output  | 0.00020801 | 0.00020801 | 0.00020801 |   0.0 |  0.00
Modify  | 0.44201    | 0.44201    | 0.44201    |   0.0 |  0.32
Other   |            | 0.06602    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135376.0 ave      135376 max      135376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135376
Ave neighs/atom = 67.688000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.01585349071, Press = -0.913590597017537
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -13447.469   -13447.469   -13535.153   -13535.153    339.34659    339.34659    31328.862    31328.862    1.4156699    1.4156699 
   57000   -13444.316   -13444.316   -13531.505   -13531.505    337.43102    337.43102    31350.579    31350.579   -1179.3363   -1179.3363 
Loop time of 139.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.806 hours/ns, 7.158 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    | 139.08     | 139.08     | 139.08     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11068    | 0.11068    | 0.11068    |   0.0 |  0.08
Output  | 0.00018687 | 0.00018687 | 0.00018687 |   0.0 |  0.00
Modify  | 0.44223    | 0.44223    | 0.44223    |   0.0 |  0.32
Other   |            | 0.06627    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134710.0 ave      134710 max      134710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134710
Ave neighs/atom = 67.355000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.978172496847, Press = -1.45242688713365
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13444.316   -13444.316   -13531.505   -13531.505    337.43102    337.43102    31350.579    31350.579   -1179.3363   -1179.3363 
   58000   -13446.241   -13446.241   -13531.963   -13531.963    331.75265    331.75265    31333.597    31333.597   -201.79518   -201.79518 
Loop time of 137.42 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.629 ns/day, 38.172 hours/ns, 7.277 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    | 136.81     | 136.81     | 136.81     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10849    | 0.10849    | 0.10849    |   0.0 |  0.08
Output  | 0.00019492 | 0.00019492 | 0.00019492 |   0.0 |  0.00
Modify  | 0.43554    | 0.43554    | 0.43554    |   0.0 |  0.32
Other   |            | 0.06585    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134582.0 ave      134582 max      134582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134582
Ave neighs/atom = 67.291000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.971840535498, Press = -1.92553563525219
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -13446.241   -13446.241   -13531.963   -13531.963    331.75265    331.75265    31333.597    31333.597   -201.79518   -201.79518 
   59000   -13445.037   -13445.037   -13531.714   -13531.714    335.44589    335.44589    31328.891    31328.891    518.41116    518.41116 
Loop time of 139.069 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.630 hours/ns, 7.191 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.45     | 138.45     | 138.45     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11031    | 0.11031    | 0.11031    |   0.0 |  0.08
Output  | 0.00019921 | 0.00019921 | 0.00019921 |   0.0 |  0.00
Modify  | 0.44319    | 0.44319    | 0.44319    |   0.0 |  0.32
Other   |            | 0.06733    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134796.0 ave      134796 max      134796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134796
Ave neighs/atom = 67.398000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.035867140444, Press = -1.75016755130676
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -13445.037   -13445.037   -13531.714   -13531.714    335.44589    335.44589    31328.891    31328.891    518.41116    518.41116 
   60000    -13443.21    -13443.21   -13533.153   -13533.153    348.09001    348.09001     31333.89     31333.89    141.10685    141.10685 
Loop time of 139.216 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.671 hours/ns, 7.183 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.6      | 138.6      | 138.6      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11       | 0.11       | 0.11       |   0.0 |  0.08
Output  | 0.00019388 | 0.00019388 | 0.00019388 |   0.0 |  0.00
Modify  | 0.44222    | 0.44222    | 0.44222    |   0.0 |  0.32
Other   |            | 0.06726    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134810.0 ave      134810 max      134810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134810
Ave neighs/atom = 67.405000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.045758886539, Press = -1.5332110933744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000    -13443.21    -13443.21   -13533.153   -13533.153    348.09001    348.09001     31333.89     31333.89    141.10685    141.10685 
   61000   -13444.733   -13444.733   -13531.601   -13531.601    336.18799    336.18799    31330.287    31330.287    533.31973    533.31973 
Loop time of 139.232 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.676 hours/ns, 7.182 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.61     | 138.61     | 138.61     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11023    | 0.11023    | 0.11023    |   0.0 |  0.08
Output  | 0.00021772 | 0.00021772 | 0.00021772 |   0.0 |  0.00
Modify  | 0.44104    | 0.44104    | 0.44104    |   0.0 |  0.32
Other   |            | 0.06696    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134652.0 ave      134652 max      134652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134652
Ave neighs/atom = 67.326000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.110429783573, Press = -1.31658361092446
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -13444.733   -13444.733   -13531.601   -13531.601    336.18799    336.18799    31330.287    31330.287    533.31973    533.31973 
   62000   -13445.791   -13445.791   -13531.188   -13531.188    330.49791    330.49791    31353.122    31353.122   -1573.1476   -1573.1476 
Loop time of 139.853 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.848 hours/ns, 7.150 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.23     | 139.23     | 139.23     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10984    | 0.10984    | 0.10984    |   0.0 |  0.08
Output  | 0.00026063 | 0.00026063 | 0.00026063 |   0.0 |  0.00
Modify  | 0.44161    | 0.44161    | 0.44161    |   0.0 |  0.32
Other   |            | 0.06643    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134872.0 ave      134872 max      134872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134872
Ave neighs/atom = 67.436000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.13739882092, Press = -1.19275049979117
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -13445.791   -13445.791   -13531.188   -13531.188    330.49791    330.49791    31353.122    31353.122   -1573.1476   -1573.1476 
   63000   -13448.584   -13448.584    -13533.43    -13533.43    328.36161    328.36161    31363.767    31363.767   -2743.0681   -2743.0681 
Loop time of 139.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.739 hours/ns, 7.170 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.84     | 138.84     | 138.84     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10913    | 0.10913    | 0.10913    |   0.0 |  0.08
Output  | 0.00026074 | 0.00026074 | 0.00026074 |   0.0 |  0.00
Modify  | 0.44121    | 0.44121    | 0.44121    |   0.0 |  0.32
Other   |            | 0.06621    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134588.0 ave      134588 max      134588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134588
Ave neighs/atom = 67.294000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.171410018039, Press = -2.02824460762125
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -13448.584   -13448.584    -13533.43    -13533.43    328.36161    328.36161    31363.767    31363.767   -2743.0681   -2743.0681 
   64000   -13446.296   -13446.296    -13531.08    -13531.08    328.12164    328.12164    31330.344    31330.344    461.22341    461.22341 
Loop time of 139.754 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.821 hours/ns, 7.155 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.14     | 139.14     | 139.14     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10912    | 0.10912    | 0.10912    |   0.0 |  0.08
Output  | 0.00019348 | 0.00019348 | 0.00019348 |   0.0 |  0.00
Modify  | 0.44049    | 0.44049    | 0.44049    |   0.0 |  0.32
Other   |            | 0.0666     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134416.0 ave      134416 max      134416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134416
Ave neighs/atom = 67.208000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.156494124848, Press = -2.59835992753761
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -13446.296   -13446.296    -13531.08    -13531.08    328.12164    328.12164    31330.344    31330.344    461.22341    461.22341 
   65000   -13450.638   -13450.638   -13534.418   -13534.418    324.23729    324.23729    31290.406    31290.406    3348.3992    3348.3992 
Loop time of 140.159 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.933 hours/ns, 7.135 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.54     | 139.54     | 139.54     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11       | 0.11       | 0.11       |   0.0 |  0.08
Output  | 0.00015511 | 0.00015511 | 0.00015511 |   0.0 |  0.00
Modify  | 0.44206    | 0.44206    | 0.44206    |   0.0 |  0.32
Other   |            | 0.06695    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135042.0 ave      135042 max      135042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135042
Ave neighs/atom = 67.521000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.15532036195, Press = -1.55565051158385
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -13450.638   -13450.638   -13534.418   -13534.418    324.23729    324.23729    31290.406    31290.406    3348.3992    3348.3992 
   66000   -13444.524   -13444.524     -13529.7     -13529.7    329.63929    329.63929    31328.716    31328.716    781.34428    781.34428 
Loop time of 125.972 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 34.992 hours/ns, 7.938 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    | 125.43     | 125.43     | 125.43     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099757   | 0.099757   | 0.099757   |   0.0 |  0.08
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.37826    | 0.37826    | 0.37826    |   0.0 |  0.30
Other   |            | 0.06246    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135136.0 ave      135136 max      135136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135136
Ave neighs/atom = 67.568000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.108965811266, Press = -0.92094844328684
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -13444.524   -13444.524     -13529.7     -13529.7    329.63929    329.63929    31328.716    31328.716    781.34428    781.34428 
   67000   -13449.893   -13449.893   -13534.081   -13534.081    325.81308    325.81308    31339.235    31339.235    -712.0203    -712.0203 
Loop time of 119.444 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.179 hours/ns, 8.372 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.94     | 118.94     | 118.94     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093754   | 0.093754   | 0.093754   |   0.0 |  0.08
Output  | 0.00047117 | 0.00047117 | 0.00047117 |   0.0 |  0.00
Modify  | 0.34985    | 0.34985    | 0.34985    |   0.0 |  0.29
Other   |            | 0.0609     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135250.0 ave      135250 max      135250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135250
Ave neighs/atom = 67.625000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.073515280588, Press = -1.23670589067409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -13449.893   -13449.893   -13534.081   -13534.081    325.81308    325.81308    31339.235    31339.235    -712.0203    -712.0203 
   68000   -13446.425   -13446.425   -13532.485   -13532.485    333.05837    333.05837    31346.497    31346.497   -879.50735   -879.50735 
Loop time of 119.228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.119 hours/ns, 8.387 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.72     | 118.72     | 118.72     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093955   | 0.093955   | 0.093955   |   0.0 |  0.08
Output  | 0.00015415 | 0.00015415 | 0.00015415 |   0.0 |  0.00
Modify  | 0.35139    | 0.35139    | 0.35139    |   0.0 |  0.29
Other   |            | 0.0613     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134590.0 ave      134590 max      134590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134590
Ave neighs/atom = 67.295000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.077029087318, Press = -1.52265532795806
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -13446.425   -13446.425   -13532.485   -13532.485    333.05837    333.05837    31346.497    31346.497   -879.50735   -879.50735 
   69000   -13446.861   -13446.861   -13533.237   -13533.237    334.28315    334.28315    31333.866    31333.866   -78.939647   -78.939647 
Loop time of 119.017 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.060 hours/ns, 8.402 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.51     | 118.51     | 118.51     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093834   | 0.093834   | 0.093834   |   0.0 |  0.08
Output  | 0.00019313 | 0.00019313 | 0.00019313 |   0.0 |  0.00
Modify  | 0.3502     | 0.3502     | 0.3502     |   0.0 |  0.29
Other   |            | 0.06106    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134546.0 ave      134546 max      134546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134546
Ave neighs/atom = 67.273000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.088203219079, Press = -1.84302271560126
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -13446.861   -13446.861   -13533.237   -13533.237    334.28315    334.28315    31333.866    31333.866   -78.939647   -78.939647 
   70000   -13443.913   -13443.913   -13532.781   -13532.781    343.92797    343.92797    31303.444    31303.444    2442.7301    2442.7301 
Loop time of 118.975 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.049 hours/ns, 8.405 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.47     | 118.47     | 118.47     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09393    | 0.09393    | 0.09393    |   0.0 |  0.08
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.34623    | 0.34623    | 0.34623    |   0.0 |  0.29
Other   |            | 0.0608     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134566.0 ave      134566 max      134566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134566
Ave neighs/atom = 67.283000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.129821304764, Press = -1.27419972498508
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -13443.913   -13443.913   -13532.781   -13532.781    343.92797    343.92797    31303.444    31303.444    2442.7301    2442.7301 
   71000   -13447.634   -13447.634   -13531.548   -13531.548    324.75804    324.75804    31318.976    31318.976    1095.4325    1095.4325 
Loop time of 122.74 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.704 ns/day, 34.094 hours/ns, 8.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    | 122.22     | 122.22     | 122.22     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09751    | 0.09751    | 0.09751    |   0.0 |  0.08
Output  | 0.00015475 | 0.00015475 | 0.00015475 |   0.0 |  0.00
Modify  | 0.36531    | 0.36531    | 0.36531    |   0.0 |  0.30
Other   |            | 0.06046    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135114.0 ave      135114 max      135114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135114
Ave neighs/atom = 67.557000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.165981695436, Press = -0.486154391989141
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -13447.634   -13447.634   -13531.548   -13531.548    324.75804    324.75804    31318.976    31318.976    1095.4325    1095.4325 
   72000   -13439.767   -13439.767   -13529.467   -13529.467    347.15075    347.15075    31370.575    31370.575   -2463.4784   -2463.4784 
Loop time of 140.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.956 hours/ns, 7.131 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.62     | 139.62     | 139.62     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10988    | 0.10988    | 0.10988    |   0.0 |  0.08
Output  | 0.00019788 | 0.00019788 | 0.00019788 |   0.0 |  0.00
Modify  | 0.44542    | 0.44542    | 0.44542    |   0.0 |  0.32
Other   |            | 0.06667    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135018.0 ave      135018 max      135018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135018
Ave neighs/atom = 67.509000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.19208275623, Press = -0.860294428164476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -13439.767   -13439.767   -13529.467   -13529.467    347.15075    347.15075    31370.575    31370.575   -2463.4784   -2463.4784 
   73000   -13446.768   -13446.768   -13532.526   -13532.526    331.89054    331.89054    31360.038    31360.038   -2018.6269   -2018.6269 
Loop time of 140.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.902 hours/ns, 7.140 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.43     | 139.43     | 139.43     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11044    | 0.11044    | 0.11044    |   0.0 |  0.08
Output  | 0.00021652 | 0.00021652 | 0.00021652 |   0.0 |  0.00
Modify  | 0.44494    | 0.44494    | 0.44494    |   0.0 |  0.32
Other   |            | 0.06671    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134470.0 ave      134470 max      134470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134470
Ave neighs/atom = 67.235000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.215892960182, Press = -1.70526530722492
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -13446.768   -13446.768   -13532.526   -13532.526    331.89054    331.89054    31360.038    31360.038   -2018.6269   -2018.6269 
   74000   -13449.958   -13449.958   -13533.296   -13533.296    322.52416    322.52416     31327.63     31327.63    211.49852    211.49852 
Loop time of 139.818 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.838 hours/ns, 7.152 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.2      | 139.2      | 139.2      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10984    | 0.10984    | 0.10984    |   0.0 |  0.08
Output  | 0.00018858 | 0.00018858 | 0.00018858 |   0.0 |  0.00
Modify  | 0.44021    | 0.44021    | 0.44021    |   0.0 |  0.31
Other   |            | 0.06625    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134530.0 ave      134530 max      134530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134530
Ave neighs/atom = 67.265000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.205934319605, Press = -1.71058916142852
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -13449.958   -13449.958   -13533.296   -13533.296    322.52416    322.52416     31327.63     31327.63    211.49852    211.49852 
   75000   -13444.676   -13444.676   -13532.997   -13532.997     341.8121     341.8121    31331.037    31331.037     20.21521     20.21521 
Loop time of 120.341 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.718 ns/day, 33.428 hours/ns, 8.310 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.83     | 119.83     | 119.83     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095066   | 0.095066   | 0.095066   |   0.0 |  0.08
Output  | 0.00019122 | 0.00019122 | 0.00019122 |   0.0 |  0.00
Modify  | 0.35253    | 0.35253    | 0.35253    |   0.0 |  0.29
Other   |            | 0.05855    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134882.0 ave      134882 max      134882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134882
Ave neighs/atom = 67.441000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.171336670988, Press = -1.46597760629043
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -13444.676   -13444.676   -13532.997   -13532.997     341.8121     341.8121    31331.037    31331.037     20.21521     20.21521 
   76000   -13449.161   -13449.161   -13533.917   -13533.917    328.01353    328.01353    31328.536    31328.536   -130.75705   -130.75705 
Loop time of 119.749 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.264 hours/ns, 8.351 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.25     | 119.25     | 119.25     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095601   | 0.095601   | 0.095601   |   0.0 |  0.08
Output  | 0.00015384 | 0.00015384 | 0.00015384 |   0.0 |  0.00
Modify  | 0.34971    | 0.34971    | 0.34971    |   0.0 |  0.29
Other   |            | 0.05799    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134722.0 ave      134722 max      134722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134722
Ave neighs/atom = 67.361000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.132019126892, Press = -1.20853251976855
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -13449.161   -13449.161   -13533.917   -13533.917    328.01353    328.01353    31328.536    31328.536   -130.75705   -130.75705 
   77000   -13447.771   -13447.771   -13532.264   -13532.264    326.99401    326.99401    31346.185    31346.185   -1068.8551   -1068.8551 
Loop time of 129.253 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.668 ns/day, 35.904 hours/ns, 7.737 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.7      | 128.7      | 128.7      |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10204    | 0.10204    | 0.10204    |   0.0 |  0.08
Output  | 0.00019617 | 0.00019617 | 0.00019617 |   0.0 |  0.00
Modify  | 0.39396    | 0.39396    | 0.39396    |   0.0 |  0.30
Other   |            | 0.0614     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134830.0 ave      134830 max      134830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134830
Ave neighs/atom = 67.415000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.126967267793, Press = -1.28665260674432
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -13447.771   -13447.771   -13532.264   -13532.264    326.99401    326.99401    31346.185    31346.185   -1068.8551   -1068.8551 
   78000   -13443.379   -13443.379   -13530.054   -13530.054    335.44268    335.44268    31361.153    31361.153   -1964.6819   -1964.6819 
Loop time of 140.093 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.915 hours/ns, 7.138 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.47     | 139.47     | 139.47     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11012    | 0.11012    | 0.11012    |   0.0 |  0.08
Output  | 0.00021248 | 0.00021248 | 0.00021248 |   0.0 |  0.00
Modify  | 0.44305    | 0.44305    | 0.44305    |   0.0 |  0.32
Other   |            | 0.06611    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134734.0 ave      134734 max      134734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134734
Ave neighs/atom = 67.367000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.148057223055, Press = -1.9188410640344
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -13443.379   -13443.379   -13530.054   -13530.054    335.44268    335.44268    31361.153    31361.153   -1964.6819   -1964.6819 
   79000   -13445.132   -13445.132   -13531.754   -13531.754    335.23612    335.23612    31323.685    31323.685    817.61378    817.61378 
Loop time of 134.271 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.297 hours/ns, 7.448 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.69     | 133.69     | 133.69     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10518    | 0.10518    | 0.10518    |   0.0 |  0.08
Output  | 0.00015624 | 0.00015624 | 0.00015624 |   0.0 |  0.00
Modify  | 0.41543    | 0.41543    | 0.41543    |   0.0 |  0.31
Other   |            | 0.0636     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134870.0 ave      134870 max      134870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134870
Ave neighs/atom = 67.435000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.169292499067, Press = -2.06323561726012
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -13445.132   -13445.132   -13531.754   -13531.754    335.23612    335.23612    31323.685    31323.685    817.61378    817.61378 
   80000   -13447.229   -13447.229   -13532.725   -13532.725    330.88151    330.88151    31294.091    31294.091    3367.2892    3367.2892 
Loop time of 119.316 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.143 hours/ns, 8.381 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    | 118.81     | 118.81     | 118.81     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09421    | 0.09421    | 0.09421    |   0.0 |  0.08
Output  | 0.00015557 | 0.00015557 | 0.00015557 |   0.0 |  0.00
Modify  | 0.35081    | 0.35081    | 0.35081    |   0.0 |  0.29
Other   |            | 0.06062    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135108.0 ave      135108 max      135108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135108
Ave neighs/atom = 67.554000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.208331493367, Press = -1.04568831882655
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -13447.229   -13447.229   -13532.725   -13532.725    330.88151    330.88151    31294.091    31294.091    3367.2892    3367.2892 
   81000   -13444.724   -13444.724   -13533.128   -13533.128     342.1329     342.1329    31334.661    31334.661   -121.02589   -121.02589 
Loop time of 119.422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.173 hours/ns, 8.374 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    | 118.91     | 118.91     | 118.91     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095096   | 0.095096   | 0.095096   |   0.0 |  0.08
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.35201    | 0.35201    | 0.35201    |   0.0 |  0.29
Other   |            | 0.05991    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135292.0 ave      135292 max      135292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135292
Ave neighs/atom = 67.646000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.207647800864, Press = -0.406764643354206
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -13444.724   -13444.724   -13533.128   -13533.128     342.1329     342.1329    31334.661    31334.661   -121.02589   -121.02589 
   82000   -13445.165   -13445.165   -13532.756   -13532.756    338.98341    338.98341    31359.357    31359.357    -2298.692    -2298.692 
Loop time of 120.008 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.720 ns/day, 33.336 hours/ns, 8.333 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.5      | 119.5      | 119.5      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096328   | 0.096328   | 0.096328   |   0.0 |  0.08
Output  | 0.00015419 | 0.00015419 | 0.00015419 |   0.0 |  0.00
Modify  | 0.35391    | 0.35391    | 0.35391    |   0.0 |  0.29
Other   |            | 0.05935    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134942.0 ave      134942 max      134942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134942
Ave neighs/atom = 67.471000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.169676301138, Press = -1.11990032012512
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -13445.165   -13445.165   -13532.756   -13532.756    338.98341    338.98341    31359.357    31359.357    -2298.692    -2298.692 
   83000   -13445.831   -13445.831    -13531.78    -13531.78    332.63214    332.63214    31346.638    31346.638   -1017.8857   -1017.8857 
Loop time of 140.516 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.615 ns/day, 39.032 hours/ns, 7.117 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.89     | 139.89     | 139.89     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11074    | 0.11074    | 0.11074    |   0.0 |  0.08
Output  | 0.00015458 | 0.00015458 | 0.00015458 |   0.0 |  0.00
Modify  | 0.44506    | 0.44506    | 0.44506    |   0.0 |  0.32
Other   |            | 0.06529    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134520.0 ave      134520 max      134520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134520
Ave neighs/atom = 67.260000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.14696687664, Press = -1.46190814103537
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -13445.831   -13445.831    -13531.78    -13531.78    332.63214    332.63214    31346.638    31346.638   -1017.8857   -1017.8857 
   84000   -13443.493   -13443.493   -13531.968   -13531.968    342.40721    342.40721    31331.174    31331.174    392.09099    392.09099 
Loop time of 136.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.631 ns/day, 38.012 hours/ns, 7.308 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.24     | 136.24     | 136.24     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10855    | 0.10855    | 0.10855    |   0.0 |  0.08
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.43124    | 0.43124    | 0.43124    |   0.0 |  0.32
Other   |            | 0.06447    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134672.0 ave      134672 max      134672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134672
Ave neighs/atom = 67.336000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.141410376769, Press = -1.45986840931585
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -13443.493   -13443.493   -13531.968   -13531.968    342.40721    342.40721    31331.174    31331.174    392.09099    392.09099 
   85000   -13450.037   -13450.037   -13533.068   -13533.068    321.33932    321.33932    31304.109    31304.109    2352.4687    2352.4687 
Loop time of 138.278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.625 ns/day, 38.411 hours/ns, 7.232 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.67     | 137.67     | 137.67     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10836    | 0.10836    | 0.10836    |   0.0 |  0.08
Output  | 0.0002027  | 0.0002027  | 0.0002027  |   0.0 |  0.00
Modify  | 0.43428    | 0.43428    | 0.43428    |   0.0 |  0.31
Other   |            | 0.06583    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134880.0 ave      134880 max      134880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134880
Ave neighs/atom = 67.440000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.117700237308, Press = -0.893667530570444
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -13450.037   -13450.037   -13533.068   -13533.068    321.33932    321.33932    31304.109    31304.109    2352.4687    2352.4687 
   86000   -13444.816   -13444.816   -13533.766   -13533.766    344.24667    344.24667    31339.673    31339.673   -636.27958   -636.27958 
Loop time of 127.701 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.677 ns/day, 35.473 hours/ns, 7.831 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.15     | 127.15     | 127.15     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10117    | 0.10117    | 0.10117    |   0.0 |  0.08
Output  | 0.00019676 | 0.00019676 | 0.00019676 |   0.0 |  0.00
Modify  | 0.38796    | 0.38796    | 0.38796    |   0.0 |  0.30
Other   |            | 0.06161    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135140.0 ave      135140 max      135140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135140
Ave neighs/atom = 67.570000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.101188237839, Press = -0.227185494806374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -13444.816   -13444.816   -13533.766   -13533.766    344.24667    344.24667    31339.673    31339.673   -636.27958   -636.27958 
   87000    -13446.92    -13446.92   -13530.035   -13530.035    321.66404    321.66404    31372.802    31372.802    -2982.696    -2982.696 
Loop time of 139.534 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.759 hours/ns, 7.167 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    | 138.92     | 138.92     | 138.92     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10932    | 0.10932    | 0.10932    |   0.0 |  0.08
Output  | 0.00019383 | 0.00019383 | 0.00019383 |   0.0 |  0.00
Modify  | 0.44046    | 0.44046    | 0.44046    |   0.0 |  0.32
Other   |            | 0.06499    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134706.0 ave      134706 max      134706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134706
Ave neighs/atom = 67.353000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.062267454628, Press = -0.993949688570929
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000    -13446.92    -13446.92   -13530.035   -13530.035    321.66404    321.66404    31372.802    31372.802    -2982.696    -2982.696 
   88000   -13446.746   -13446.746   -13531.671   -13531.671    328.66892    328.66892    31346.956    31346.956   -986.45694   -986.45694 
Loop time of 139.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.710 hours/ns, 7.176 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.75     | 138.75     | 138.75     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10951    | 0.10951    | 0.10951    |   0.0 |  0.08
Output  | 0.00019716 | 0.00019716 | 0.00019716 |   0.0 |  0.00
Modify  | 0.43352    | 0.43352    | 0.43352    |   0.0 |  0.31
Other   |            | 0.06619    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134492.0 ave      134492 max      134492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134492
Ave neighs/atom = 67.246000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.048358107251, Press = -1.59307539349735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -13446.746   -13446.746   -13531.671   -13531.671    328.66892    328.66892    31346.956    31346.956   -986.45694   -986.45694 
   89000   -13442.428   -13442.428   -13530.983   -13530.983    342.71871    342.71871    31325.503    31325.503    1162.2335    1162.2335 
Loop time of 139.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.871 hours/ns, 7.146 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.32     | 139.32     | 139.32     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10975    | 0.10975    | 0.10975    |   0.0 |  0.08
Output  | 0.00019295 | 0.00019295 | 0.00019295 |   0.0 |  0.00
Modify  | 0.43975    | 0.43975    | 0.43975    |   0.0 |  0.31
Other   |            | 0.06693    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134640.0 ave      134640 max      134640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134640
Ave neighs/atom = 67.320000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.035523155795, Press = -1.41616102155667
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -13442.428   -13442.428   -13530.983   -13530.983    342.71871    342.71871    31325.503    31325.503    1162.2335    1162.2335 
   90000   -13446.344   -13446.344   -13530.613   -13530.613    326.13006    326.13006    31323.872    31323.872    1022.3613    1022.3613 
Loop time of 139.493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.748 hours/ns, 7.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    | 138.87     | 138.87     | 138.87     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10897    | 0.10897    | 0.10897    |   0.0 |  0.08
Output  | 0.00015452 | 0.00015452 | 0.00015452 |   0.0 |  0.00
Modify  | 0.44212    | 0.44212    | 0.44212    |   0.0 |  0.32
Other   |            | 0.06676    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134870.0 ave      134870 max      134870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134870
Ave neighs/atom = 67.435000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.062071586956, Press = -0.919306992307798
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -13446.344   -13446.344   -13530.613   -13530.613    326.13006    326.13006    31323.872    31323.872    1022.3613    1022.3613 
   91000   -13442.313   -13442.313   -13530.068   -13530.068    339.62332    339.62332    31345.297    31345.297   -799.29606   -799.29606 
Loop time of 141.157 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.612 ns/day, 39.210 hours/ns, 7.084 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.53     | 140.53     | 140.53     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11079    | 0.11079    | 0.11079    |   0.0 |  0.08
Output  | 0.00015488 | 0.00015488 | 0.00015488 |   0.0 |  0.00
Modify  | 0.44796    | 0.44796    | 0.44796    |   0.0 |  0.32
Other   |            | 0.06605    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135020.0 ave      135020 max      135020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135020
Ave neighs/atom = 67.510000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.073530890002, Press = -1.03053681396308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -13442.313   -13442.313   -13530.068   -13530.068    339.62332    339.62332    31345.297    31345.297   -799.29606   -799.29606 
   92000   -13445.897   -13445.897   -13530.394   -13530.394    327.01463    327.01463    31344.457    31344.457   -802.50273   -802.50273 
Loop time of 139.348 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.708 hours/ns, 7.176 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.73     | 138.73     | 138.73     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10936    | 0.10936    | 0.10936    |   0.0 |  0.08
Output  | 0.00015488 | 0.00015488 | 0.00015488 |   0.0 |  0.00
Modify  | 0.44047    | 0.44047    | 0.44047    |   0.0 |  0.32
Other   |            | 0.0653     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134996.0 ave      134996 max      134996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134996
Ave neighs/atom = 67.498000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.077956037499, Press = -1.30665168777447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -13445.897   -13445.897   -13530.394   -13530.394    327.01463    327.01463    31344.457    31344.457   -802.50273   -802.50273 
   93000   -13444.061   -13444.061   -13531.578   -13531.578    338.69841    338.69841     31336.16     31336.16   -131.70441   -131.70441 
Loop time of 139.64 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.789 hours/ns, 7.161 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.02     | 139.02     | 139.02     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10973    | 0.10973    | 0.10973    |   0.0 |  0.08
Output  | 0.0013459  | 0.0013459  | 0.0013459  |   0.0 |  0.00
Modify  | 0.44122    | 0.44122    | 0.44122    |   0.0 |  0.32
Other   |            | 0.06588    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134936.0 ave      134936 max      134936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134936
Ave neighs/atom = 67.468000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.064978208241, Press = -1.68467849172437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -13444.061   -13444.061   -13531.578   -13531.578    338.69841    338.69841     31336.16     31336.16   -131.70441   -131.70441 
   94000   -13449.961   -13449.961   -13533.571   -13533.571    323.57996    323.57996    31288.826    31288.826    3526.7611    3526.7611 
Loop time of 137.534 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.628 ns/day, 38.204 hours/ns, 7.271 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.93     | 136.93     | 136.93     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10846    | 0.10846    | 0.10846    |   0.0 |  0.08
Output  | 0.00019727 | 0.00019727 | 0.00019727 |   0.0 |  0.00
Modify  | 0.43468    | 0.43468    | 0.43468    |   0.0 |  0.32
Other   |            | 0.06538    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134820.0 ave      134820 max      134820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134820
Ave neighs/atom = 67.410000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.042296068747, Press = -1.33958481225204
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -13449.961   -13449.961   -13533.571   -13533.571    323.57996    323.57996    31288.826    31288.826    3526.7611    3526.7611 
   95000   -13444.264   -13444.264   -13531.753   -13531.753     338.5908     338.5908    31306.143    31306.143    2379.4949    2379.4949 
Loop time of 136.592 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.99     | 135.99     | 135.99     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10648    | 0.10648    | 0.10648    |   0.0 |  0.08
Output  | 0.00020994 | 0.00020994 | 0.00020994 |   0.0 |  0.00
Modify  | 0.42737    | 0.42737    | 0.42737    |   0.0 |  0.31
Other   |            | 0.06474    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135176.0 ave      135176 max      135176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135176
Ave neighs/atom = 67.588000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.027707848337, Press = -0.378158970512499
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -13444.264   -13444.264   -13531.753   -13531.753     338.5908     338.5908    31306.143    31306.143    2379.4949    2379.4949 
   96000   -13441.932   -13441.932   -13530.845   -13530.845    344.10247    344.10247    31356.628    31356.628   -1782.3828   -1782.3828 
Loop time of 139.813 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.837 hours/ns, 7.152 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.19     | 139.19     | 139.19     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10958    | 0.10958    | 0.10958    |   0.0 |  0.08
Output  | 0.00015531 | 0.00015531 | 0.00015531 |   0.0 |  0.00
Modify  | 0.44567    | 0.44567    | 0.44567    |   0.0 |  0.32
Other   |            | 0.0659     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135228.0 ave      135228 max      135228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135228
Ave neighs/atom = 67.614000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.025072977131, Press = -0.756626579099312
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -13441.932   -13441.932   -13530.845   -13530.845    344.10247    344.10247    31356.628    31356.628   -1782.3828   -1782.3828 
   97000   -13446.155   -13446.155   -13532.399   -13532.399    333.77153    333.77153    31348.844    31348.844    -1354.593    -1354.593 
Loop time of 139.595 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.776 hours/ns, 7.164 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.97     | 138.97     | 138.97     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10973    | 0.10973    | 0.10973    |   0.0 |  0.08
Output  | 0.0001992  | 0.0001992  | 0.0001992  |   0.0 |  0.00
Modify  | 0.44485    | 0.44485    | 0.44485    |   0.0 |  0.32
Other   |            | 0.06673    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134662.0 ave      134662 max      134662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134662
Ave neighs/atom = 67.331000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.030483182162, Press = -1.18066143267315
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -13446.155   -13446.155   -13532.399   -13532.399    333.77153    333.77153    31348.844    31348.844    -1354.593    -1354.593 
   98000   -13443.317   -13443.317   -13531.282   -13531.282    340.43316    340.43316    31342.645    31342.645   -613.45811   -613.45811 
Loop time of 140.224 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.951 hours/ns, 7.131 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.6      | 139.6      | 139.6      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11056    | 0.11056    | 0.11056    |   0.0 |  0.08
Output  | 0.00019585 | 0.00019585 | 0.00019585 |   0.0 |  0.00
Modify  | 0.44581    | 0.44581    | 0.44581    |   0.0 |  0.32
Other   |            | 0.06695    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134846.0 ave      134846 max      134846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134846
Ave neighs/atom = 67.423000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.025538269917, Press = -1.16982277029975
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -13443.317   -13443.317   -13531.282   -13531.282    340.43316    340.43316    31342.645    31342.645   -613.45811   -613.45811 
   99000   -13445.378   -13445.378   -13531.216   -13531.216    332.20164    332.20164    31334.172    31334.172    27.011738    27.011738 
Loop time of 140.13 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.925 hours/ns, 7.136 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.5      | 139.5      | 139.5      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11117    | 0.11117    | 0.11117    |   0.0 |  0.08
Output  | 0.00019707 | 0.00019707 | 0.00019707 |   0.0 |  0.00
Modify  | 0.44787    | 0.44787    | 0.44787    |   0.0 |  0.32
Other   |            | 0.06713    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134818.0 ave      134818 max      134818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134818
Ave neighs/atom = 67.409000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.029130067084, Press = -1.08275039318494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -13445.378   -13445.378   -13531.216   -13531.216    332.20164    332.20164    31334.172    31334.172    27.011738    27.011738 
  100000   -13447.115   -13447.115   -13531.784   -13531.784    327.68034    327.68034    31333.366    31333.366   -73.253766   -73.253766 
Loop time of 140.237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.955 hours/ns, 7.131 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.61     | 139.61     | 139.61     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11016    | 0.11016    | 0.11016    |   0.0 |  0.08
Output  | 0.00015601 | 0.00015601 | 0.00015601 |   0.0 |  0.00
Modify  | 0.44537    | 0.44537    | 0.44537    |   0.0 |  0.32
Other   |            | 0.06809    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134968.0 ave      134968 max      134968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134968
Ave neighs/atom = 67.484000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.034286846047, Press = -1.06947522161515
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -13447.115   -13447.115   -13531.784   -13531.784    327.68034    327.68034    31333.366    31333.366   -73.253766   -73.253766 
  101000   -13444.102   -13444.102   -13531.144   -13531.144    336.85915    336.85915    31336.566    31336.566   -49.264874   -49.264874 
Loop time of 132.36 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.767 hours/ns, 7.555 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.78     | 131.78     | 131.78     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10403    | 0.10403    | 0.10403    |   0.0 |  0.08
Output  | 0.00015535 | 0.00015535 | 0.00015535 |   0.0 |  0.00
Modify  | 0.40962    | 0.40962    | 0.40962    |   0.0 |  0.31
Other   |            | 0.06477    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135042.0 ave      135042 max      135042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135042
Ave neighs/atom = 67.521000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.027104317986, Press = -1.13464728315564
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -13444.102   -13444.102   -13531.144   -13531.144    336.85915    336.85915    31336.566    31336.566   -49.264874   -49.264874 
  102000   -13447.874   -13447.874   -13533.098   -13533.098    329.82761    329.82761    31332.002    31332.002   -269.07538   -269.07538 
Loop time of 140.51 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.615 ns/day, 39.031 hours/ns, 7.117 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.89     | 139.89     | 139.89     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1107     | 0.1107     | 0.1107     |   0.0 |  0.08
Output  | 0.00021315 | 0.00021315 | 0.00021315 |   0.0 |  0.00
Modify  | 0.44341    | 0.44341    | 0.44341    |   0.0 |  0.32
Other   |            | 0.06604    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134856.0 ave      134856 max      134856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134856
Ave neighs/atom = 67.428000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.00646537135, Press = -1.17567400503977
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -13447.874   -13447.874   -13533.098   -13533.098    329.82761    329.82761    31332.002    31332.002   -269.07538   -269.07538 
  103000   -13445.456   -13445.456   -13530.111   -13530.111    327.62183    327.62183    31337.476    31337.476   -137.83796   -137.83796 
Loop time of 140.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.614 ns/day, 39.062 hours/ns, 7.111 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140        | 140        | 140        |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11096    | 0.11096    | 0.11096    |   0.0 |  0.08
Output  | 0.00019559 | 0.00019559 | 0.00019559 |   0.0 |  0.00
Modify  | 0.44925    | 0.44925    | 0.44925    |   0.0 |  0.32
Other   |            | 0.0656     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134984.0 ave      134984 max      134984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134984
Ave neighs/atom = 67.492000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.003784519572, Press = -1.16267498511128
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -13445.456   -13445.456   -13530.111   -13530.111    327.62183    327.62183    31337.476    31337.476   -137.83796   -137.83796 
  104000   -13444.687   -13444.687   -13532.059   -13532.059    338.13726    338.13726    31341.582    31341.582   -738.42601   -738.42601 
Loop time of 140.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.615 ns/day, 39.024 hours/ns, 7.118 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.86     | 139.86     | 139.86     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10969    | 0.10969    | 0.10969    |   0.0 |  0.08
Output  | 0.00019882 | 0.00019882 | 0.00019882 |   0.0 |  0.00
Modify  | 0.44691    | 0.44691    | 0.44691    |   0.0 |  0.32
Other   |            | 0.06706    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135002.0 ave      135002 max      135002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135002
Ave neighs/atom = 67.501000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.004895473129, Press = -1.2733084397123
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -13444.687   -13444.687   -13532.059   -13532.059    338.13726    338.13726    31341.582    31341.582   -738.42601   -738.42601 
  105000   -13444.907   -13444.907   -13530.234   -13530.234    330.22372    330.22372    31327.521    31327.521    592.26143    592.26143 
Loop time of 122.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.705 ns/day, 34.021 hours/ns, 8.165 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.95     | 121.95     | 121.95     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097684   | 0.097684   | 0.097684   |   0.0 |  0.08
Output  | 0.00020129 | 0.00020129 | 0.00020129 |   0.0 |  0.00
Modify  | 0.36525    | 0.36525    | 0.36525    |   0.0 |  0.30
Other   |            | 0.0595     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134768.0 ave      134768 max      134768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134768
Ave neighs/atom = 67.384000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.991856945323, Press = -1.29245624661447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -13444.907   -13444.907   -13530.234   -13530.234    330.22372    330.22372    31327.521    31327.521    592.26143    592.26143 
  106000   -13447.602   -13447.602   -13532.527   -13532.527    328.67163    328.67163    31313.172    31313.172    1581.3391    1581.3391 
Loop time of 129.845 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.068 hours/ns, 7.702 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    | 129.28     | 129.28     | 129.28     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10292    | 0.10292    | 0.10292    |   0.0 |  0.08
Output  | 0.00015476 | 0.00015476 | 0.00015476 |   0.0 |  0.00
Modify  | 0.39785    | 0.39785    | 0.39785    |   0.0 |  0.31
Other   |            | 0.06211    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135110.0 ave      135110 max      135110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135110
Ave neighs/atom = 67.555000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.002112672728, Press = -0.961341620290142
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000   -13447.602   -13447.602   -13532.527   -13532.527    328.67163    328.67163    31313.172    31313.172    1581.3391    1581.3391 
  107000   -13448.516   -13448.516   -13534.146   -13534.146     331.3942     331.3942     31332.88     31332.88   -267.85051   -267.85051 
Loop time of 130.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.189 hours/ns, 7.676 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    | 129.72     | 129.72     | 129.72     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10089    | 0.10089    | 0.10089    |   0.0 |  0.08
Output  | 0.0001552  | 0.0001552  | 0.0001552  |   0.0 |  0.00
Modify  | 0.39752    | 0.39752    | 0.39752    |   0.0 |  0.31
Other   |            | 0.06314    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135116.0 ave      135116 max      135116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135116
Ave neighs/atom = 67.558000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.004057478977, Press = -0.622684903878504
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -13448.516   -13448.516   -13534.146   -13534.146     331.3942     331.3942     31332.88     31332.88   -267.85051   -267.85051 
  108000   -13445.885   -13445.885   -13530.266   -13530.266    326.56255    326.56255    31372.426    31372.426   -3304.1816   -3304.1816 
Loop time of 119.478 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.188 hours/ns, 8.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.97     | 118.97     | 118.97     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093961   | 0.093961   | 0.093961   |   0.0 |  0.08
Output  | 0.00015565 | 0.00015565 | 0.00015565 |   0.0 |  0.00
Modify  | 0.3516     | 0.3516     | 0.3516     |   0.0 |  0.29
Other   |            | 0.05993    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134854.0 ave      134854 max      134854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134854
Ave neighs/atom = 67.427000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.015232309962, Press = -0.985678051404045
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -13445.885   -13445.885   -13530.266   -13530.266    326.56255    326.56255    31372.426    31372.426   -3304.1816   -3304.1816 
  109000   -13446.717   -13446.717    -13531.94    -13531.94    329.82153    329.82153    31346.351    31346.351   -1276.7899   -1276.7899 
Loop time of 119.132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.092 hours/ns, 8.394 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.63     | 118.63     | 118.63     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093657   | 0.093657   | 0.093657   |   0.0 |  0.08
Output  | 0.00015598 | 0.00015598 | 0.00015598 |   0.0 |  0.00
Modify  | 0.35056    | 0.35056    | 0.35056    |   0.0 |  0.29
Other   |            | 0.06053    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134618.0 ave      134618 max      134618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134618
Ave neighs/atom = 67.309000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.035627444932, Press = -1.58234340571196
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -13446.717   -13446.717    -13531.94    -13531.94    329.82153    329.82153    31346.351    31346.351   -1276.7899   -1276.7899 
  110000   -13444.503   -13444.503   -13528.342   -13528.342    324.46564    324.46564    31321.787    31321.787    1409.2383    1409.2383 
Loop time of 119.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.720 ns/day, 33.316 hours/ns, 8.338 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.43     | 119.43     | 119.43     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094249   | 0.094249   | 0.094249   |   0.0 |  0.08
Output  | 0.00015279 | 0.00015279 | 0.00015279 |   0.0 |  0.00
Modify  | 0.35365    | 0.35365    | 0.35365    |   0.0 |  0.29
Other   |            | 0.06043    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134826.0 ave      134826 max      134826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134826
Ave neighs/atom = 67.413000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.063832850798, Press = -1.17635296910114
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -13444.503   -13444.503   -13528.342   -13528.342    324.46564    324.46564    31321.787    31321.787    1409.2383    1409.2383 
  111000   -13443.638   -13443.638   -13529.622   -13529.622    332.76709    332.76709    31330.582    31330.582    583.80397    583.80397 
Loop time of 123.985 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.440 hours/ns, 8.065 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.46     | 123.46     | 123.46     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097113   | 0.097113   | 0.097113   |   0.0 |  0.08
Output  | 0.00015577 | 0.00015577 | 0.00015577 |   0.0 |  0.00
Modify  | 0.3683     | 0.3683     | 0.3683     |   0.0 |  0.30
Other   |            | 0.06066    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135146.0 ave      135146 max      135146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135146
Ave neighs/atom = 67.573000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.063316549982, Press = -0.975317318240554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -13443.638   -13443.638   -13529.622   -13529.622    332.76709    332.76709    31330.582    31330.582    583.80397    583.80397 
  112000   -13448.174   -13448.174   -13531.398   -13531.398     322.0881     322.0881    31333.829    31333.829    -8.859123    -8.859123 
Loop time of 120.372 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.718 ns/day, 33.437 hours/ns, 8.308 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.86     | 119.86     | 119.86     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095037   | 0.095037   | 0.095037   |   0.0 |  0.08
Output  | 0.00019145 | 0.00019145 | 0.00019145 |   0.0 |  0.00
Modify  | 0.3564     | 0.3564     | 0.3564     |   0.0 |  0.30
Other   |            | 0.06042    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135094.0 ave      135094 max      135094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135094
Ave neighs/atom = 67.547000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.03821615216, Press = -0.966964871793548
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -13448.174   -13448.174   -13531.398   -13531.398     322.0881     322.0881    31333.829    31333.829    -8.859123    -8.859123 
  113000   -13445.021   -13445.021   -13530.826   -13530.826    332.07283    332.07283    31339.001    31339.001   -540.88484   -540.88484 
Loop time of 119.12 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.089 hours/ns, 8.395 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.61     | 118.61     | 118.61     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093785   | 0.093785   | 0.093785   |   0.0 |  0.08
Output  | 0.00015524 | 0.00015524 | 0.00015524 |   0.0 |  0.00
Modify  | 0.35094    | 0.35094    | 0.35094    |   0.0 |  0.29
Other   |            | 0.06095    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134928.0 ave      134928 max      134928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134928
Ave neighs/atom = 67.464000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.021310817921, Press = -1.02536312846494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -13445.021   -13445.021   -13530.826   -13530.826    332.07283    332.07283    31339.001    31339.001   -540.88484   -540.88484 
  114000   -13443.366   -13443.366   -13529.415   -13529.415     333.0209     333.0209    31344.744    31344.744   -716.50734   -716.50734 
Loop time of 119.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.080 hours/ns, 8.397 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.58     | 118.58     | 118.58     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094331   | 0.094331   | 0.094331   |   0.0 |  0.08
Output  | 0.00015611 | 0.00015611 | 0.00015611 |   0.0 |  0.00
Modify  | 0.35208    | 0.35208    | 0.35208    |   0.0 |  0.30
Other   |            | 0.06087    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135032.0 ave      135032 max      135032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135032
Ave neighs/atom = 67.516000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.000593801422, Press = -1.2056697385456
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000   -13443.366   -13443.366   -13529.415   -13529.415     333.0209     333.0209    31344.744    31344.744   -716.50734   -716.50734 
  115000   -13446.146   -13446.146   -13532.482   -13532.482    334.13131    334.13131    31328.936    31328.936    292.27768    292.27768 
Loop time of 119.473 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.187 hours/ns, 8.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.97     | 118.97     | 118.97     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094165   | 0.094165   | 0.094165   |   0.0 |  0.08
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.35033    | 0.35033    | 0.35033    |   0.0 |  0.29
Other   |            | 0.06033    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135086.0 ave      135086 max      135086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135086
Ave neighs/atom = 67.543000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.012110297429, Press = -1.3597435165879
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -13446.146   -13446.146   -13532.482   -13532.482    334.13131    334.13131    31328.936    31328.936    292.27768    292.27768 
  116000   -13442.672   -13442.672   -13532.004   -13532.004    345.72205    345.72205    31305.714    31305.714    2236.6936    2236.6936 
Loop time of 118.985 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.052 hours/ns, 8.404 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.48     | 118.48     | 118.48     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094165   | 0.094165   | 0.094165   |   0.0 |  0.08
Output  | 0.00015192 | 0.00015192 | 0.00015192 |   0.0 |  0.00
Modify  | 0.34998    | 0.34998    | 0.34998    |   0.0 |  0.29
Other   |            | 0.06103    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134938.0 ave      134938 max      134938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134938
Ave neighs/atom = 67.469000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.021877340717, Press = -1.1109086647009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -13442.672   -13442.672   -13532.004   -13532.004    345.72205    345.72205    31305.714    31305.714    2236.6936    2236.6936 
  117000   -13443.464   -13443.464   -13529.695   -13529.695    333.72093    333.72093    31316.213    31316.213    1679.3535    1679.3535 
Loop time of 119.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.189 hours/ns, 8.369 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.98     | 118.98     | 118.98     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095718   | 0.095718   | 0.095718   |   0.0 |  0.08
Output  | 0.00015406 | 0.00015406 | 0.00015406 |   0.0 |  0.00
Modify  | 0.35051    | 0.35051    | 0.35051    |   0.0 |  0.29
Other   |            | 0.05917    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135390.0 ave      135390 max      135390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135390
Ave neighs/atom = 67.695000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.029668549425, Press = -0.491065138629823
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -13443.464   -13443.464   -13529.695   -13529.695    333.72093    333.72093    31316.213    31316.213    1679.3535    1679.3535 
  118000   -13447.474   -13447.474   -13531.796   -13531.796    326.33495    326.33495    31368.214    31368.214   -3106.8846   -3106.8846 
Loop time of 119.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.247 hours/ns, 8.355 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    | 119.18     | 119.18     | 119.18     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096154   | 0.096154   | 0.096154   |   0.0 |  0.08
Output  | 0.00015484 | 0.00015484 | 0.00015484 |   0.0 |  0.00
Modify  | 0.35165    | 0.35165    | 0.35165    |   0.0 |  0.29
Other   |            | 0.05903    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135334.0 ave      135334 max      135334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135334
Ave neighs/atom = 67.667000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.043291787111, Press = -0.599791109119236
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -13447.474   -13447.474   -13531.796   -13531.796    326.33495    326.33495    31368.214    31368.214   -3106.8846   -3106.8846 
  119000   -13442.003   -13442.003   -13527.799   -13527.799    332.03906    332.03906     31352.74     31352.74   -1101.6772   -1101.6772 
Loop time of 119.317 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.143 hours/ns, 8.381 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    | 118.81     | 118.81     | 118.81     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094765   | 0.094765   | 0.094765   |   0.0 |  0.08
Output  | 0.00046969 | 0.00046969 | 0.00046969 |   0.0 |  0.00
Modify  | 0.35185    | 0.35185    | 0.35185    |   0.0 |  0.29
Other   |            | 0.05899    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134598.0 ave      134598 max      134598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134598
Ave neighs/atom = 67.299000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.065736505134, Press = -1.14135089170452
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000   -13442.003   -13442.003   -13527.799   -13527.799    332.03906    332.03906     31352.74     31352.74   -1101.6772   -1101.6772 
  120000   -13444.553   -13444.553   -13531.338   -13531.338    335.86798    335.86798    31336.734    31336.734   -259.05029   -259.05029 
Loop time of 119.226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.118 hours/ns, 8.387 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    | 118.72     | 118.72     | 118.72     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094738   | 0.094738   | 0.094738   |   0.0 |  0.08
Output  | 0.00015482 | 0.00015482 | 0.00015482 |   0.0 |  0.00
Modify  | 0.35068    | 0.35068    | 0.35068    |   0.0 |  0.29
Other   |            | 0.05883    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134944.0 ave      134944 max      134944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134944
Ave neighs/atom = 67.472000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.078292053625, Press = -1.1615259429756
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -13444.553   -13444.553   -13531.338   -13531.338    335.86798    335.86798    31336.734    31336.734   -259.05029   -259.05029 
  121000   -13448.334   -13448.334   -13532.221   -13532.221    324.65191    324.65191    31318.188    31318.188    1219.0118    1219.0118 
Loop time of 119.371 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.158 hours/ns, 8.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.87     | 118.87     | 118.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095726   | 0.095726   | 0.095726   |   0.0 |  0.08
Output  | 0.00019726 | 0.00019726 | 0.00019726 |   0.0 |  0.00
Modify  | 0.3507     | 0.3507     | 0.3507     |   0.0 |  0.29
Other   |            | 0.05889    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135060.0 ave      135060 max      135060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135060
Ave neighs/atom = 67.530000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.08012130055, Press = -0.965994208175188
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000   -13448.334   -13448.334   -13532.221   -13532.221    324.65191    324.65191    31318.188    31318.188    1219.0118    1219.0118 
  122000   -13446.865   -13446.865   -13530.791   -13530.791    324.79979    324.79979    31324.933    31324.933    883.07645    883.07645 
Loop time of 119.371 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.159 hours/ns, 8.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.87     | 118.87     | 118.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094355   | 0.094355   | 0.094355   |   0.0 |  0.08
Output  | 0.00015252 | 0.00015252 | 0.00015252 |   0.0 |  0.00
Modify  | 0.35134    | 0.35134    | 0.35134    |   0.0 |  0.29
Other   |            | 0.05921    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135054.0 ave      135054 max      135054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135054
Ave neighs/atom = 67.527000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.072513910531, Press = -0.615519380247104
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  122000   -13446.865   -13446.865   -13530.791   -13530.791    324.79979    324.79979    31324.933    31324.933    883.07645    883.07645 
  123000   -13443.177   -13443.177   -13530.848   -13530.848    339.29631    339.29631    31376.555    31376.555   -3299.2456   -3299.2456 
Loop time of 119.505 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.196 hours/ns, 8.368 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    | 119        | 119        | 119        |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093973   | 0.093973   | 0.093973   |   0.0 |  0.08
Output  | 0.00015954 | 0.00015954 | 0.00015954 |   0.0 |  0.00
Modify  | 0.35195    | 0.35195    | 0.35195    |   0.0 |  0.29
Other   |            | 0.05917    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135080.0 ave      135080 max      135080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135080
Ave neighs/atom = 67.540000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.079062386228, Press = -0.734901378077244
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  123000   -13443.177   -13443.177   -13530.848   -13530.848    339.29631    339.29631    31376.555    31376.555   -3299.2456   -3299.2456 
  124000   -13447.395   -13447.395   -13531.818   -13531.818    326.72297    326.72297    31363.665    31363.665   -2506.3633   -2506.3633 
Loop time of 119.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.081 hours/ns, 8.397 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    | 118.59     | 118.59     | 118.59     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094535   | 0.094535   | 0.094535   |   0.0 |  0.08
Output  | 0.0001516  | 0.0001516  | 0.0001516  |   0.0 |  0.00
Modify  | 0.35057    | 0.35057    | 0.35057    |   0.0 |  0.29
Other   |            | 0.05924    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134504.0 ave      134504 max      134504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134504
Ave neighs/atom = 67.252000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.06675250865, Press = -1.32638851321998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  124000   -13447.395   -13447.395   -13531.818   -13531.818    326.72297    326.72297    31363.665    31363.665   -2506.3633   -2506.3633 
  125000   -13444.942   -13444.942   -13530.395   -13530.395    330.71116    330.71116    31324.556    31324.556    1066.0254    1066.0254 
Loop time of 119.139 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.094 hours/ns, 8.394 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    | 118.63     | 118.63     | 118.63     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094798   | 0.094798   | 0.094798   |   0.0 |  0.08
Output  | 0.00015307 | 0.00015307 | 0.00015307 |   0.0 |  0.00
Modify  | 0.35029    | 0.35029    | 0.35029    |   0.0 |  0.29
Other   |            | 0.05974    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134476.0 ave      134476 max      134476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134476
Ave neighs/atom = 67.238000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.06922184053, Press = -1.33029457923546
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  125000   -13444.942   -13444.942   -13530.395   -13530.395    330.71116    330.71116    31324.556    31324.556    1066.0254    1066.0254 
  126000   -13444.337   -13444.337   -13531.996   -13531.996     339.2492     339.2492    31317.539    31317.539    1317.3197    1317.3197 
Loop time of 119.423 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.173 hours/ns, 8.374 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    | 118.92     | 118.92     | 118.92     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094729   | 0.094729   | 0.094729   |   0.0 |  0.08
Output  | 0.0001539  | 0.0001539  | 0.0001539  |   0.0 |  0.00
Modify  | 0.35109    | 0.35109    | 0.35109    |   0.0 |  0.29
Other   |            | 0.05911    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134974.0 ave      134974 max      134974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134974
Ave neighs/atom = 67.487000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.068588405507, Press = -0.895533237884027
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  126000   -13444.337   -13444.337   -13531.996   -13531.996     339.2492     339.2492    31317.539    31317.539    1317.3197    1317.3197 
  127000   -13445.576   -13445.576   -13531.506   -13531.506    332.55826    332.55826     31337.12     31337.12   -304.15281   -304.15281 
Loop time of 119.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.177 hours/ns, 8.373 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.93     | 118.93     | 118.93     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094615   | 0.094615   | 0.094615   |   0.0 |  0.08
Output  | 0.00019326 | 0.00019326 | 0.00019326 |   0.0 |  0.00
Modify  | 0.35053    | 0.35053    | 0.35053    |   0.0 |  0.29
Other   |            | 0.05895    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135282.0 ave      135282 max      135282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135282
Ave neighs/atom = 67.641000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.094498262939, Press = -0.898454369222359
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  127000   -13445.576   -13445.576   -13531.506   -13531.506    332.55826    332.55826     31337.12     31337.12   -304.15281   -304.15281 
  128000   -13442.856   -13442.856   -13531.326   -13531.326    342.38779    342.38779    31346.074    31346.074   -818.18881   -818.18881 
Loop time of 119.063 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.073 hours/ns, 8.399 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.56     | 118.56     | 118.56     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096108   | 0.096108   | 0.096108   |   0.0 |  0.08
Output  | 0.00015343 | 0.00015343 | 0.00015343 |   0.0 |  0.00
Modify  | 0.3513     | 0.3513     | 0.3513     |   0.0 |  0.30
Other   |            | 0.05901    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134816.0 ave      134816 max      134816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134816
Ave neighs/atom = 67.408000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.093763556322, Press = -1.056008183225
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  128000   -13442.856   -13442.856   -13531.326   -13531.326    342.38779    342.38779    31346.074    31346.074   -818.18881   -818.18881 
  129000   -13444.079   -13444.079   -13530.851   -13530.851    335.81707    335.81707    31343.702    31343.702   -696.66754   -696.66754 
Loop time of 119.115 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.088 hours/ns, 8.395 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.61     | 118.61     | 118.61     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094439   | 0.094439   | 0.094439   |   0.0 |  0.08
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.35061    | 0.35061    | 0.35061    |   0.0 |  0.29
Other   |            | 0.05909    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134772.0 ave      134772 max      134772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134772
Ave neighs/atom = 67.386000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.095797458812, Press = -1.1573977863698
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  129000   -13444.079   -13444.079   -13530.851   -13530.851    335.81707    335.81707    31343.702    31343.702   -696.66754   -696.66754 
  130000   -13445.649   -13445.649   -13532.006   -13532.006    334.21128    334.21128    31304.432    31304.432    2208.1345    2208.1345 
Loop time of 119.314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.143 hours/ns, 8.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.81     | 118.81     | 118.81     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09567    | 0.09567    | 0.09567    |   0.0 |  0.08
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.35022    | 0.35022    | 0.35022    |   0.0 |  0.29
Other   |            | 0.05927    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134904.0 ave      134904 max      134904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134904
Ave neighs/atom = 67.452000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.124274164394, Press = -1.15657079621986
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  130000   -13445.649   -13445.649   -13532.006   -13532.006    334.21128    334.21128    31304.432    31304.432    2208.1345    2208.1345 
  131000   -13441.293   -13441.293   -13530.552   -13530.552    345.44017    345.44017     31307.95     31307.95    2533.0103    2533.0103 
Loop time of 119.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.207 hours/ns, 8.365 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.04     | 119.04     | 119.04     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095013   | 0.095013   | 0.095013   |   0.0 |  0.08
Output  | 0.00015329 | 0.00015329 | 0.00015329 |   0.0 |  0.00
Modify  | 0.35072    | 0.35072    | 0.35072    |   0.0 |  0.29
Other   |            | 0.05889    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135478.0 ave      135478 max      135478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135478
Ave neighs/atom = 67.739000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.136583743428, Press = -0.479341885409218
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  131000   -13441.293   -13441.293   -13530.552   -13530.552    345.44017    345.44017     31307.95     31307.95    2533.0103    2533.0103 
  132000    -13444.45    -13444.45   -13530.263   -13530.263    332.10666    332.10666    31356.734    31356.734   -1705.4235   -1705.4235 
Loop time of 119.622 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.228 hours/ns, 8.360 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.12     | 119.12     | 119.12     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094342   | 0.094342   | 0.094342   |   0.0 |  0.08
Output  | 0.00015537 | 0.00015537 | 0.00015537 |   0.0 |  0.00
Modify  | 0.35087    | 0.35087    | 0.35087    |   0.0 |  0.29
Other   |            | 0.05926    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135206.0 ave      135206 max      135206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135206
Ave neighs/atom = 67.603000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.13284963581, Press = -0.623657129638924
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  132000    -13444.45    -13444.45   -13530.263   -13530.263    332.10666    332.10666    31356.734    31356.734   -1705.4235   -1705.4235 
  133000   -13449.765   -13449.765   -13533.905   -13533.905    325.63196    325.63196     31357.04     31357.04   -2212.4916   -2212.4916 
Loop time of 119.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.116 hours/ns, 8.388 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    | 118.71     | 118.71     | 118.71     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094178   | 0.094178   | 0.094178   |   0.0 |  0.08
Output  | 0.00015359 | 0.00015359 | 0.00015359 |   0.0 |  0.00
Modify  | 0.35088    | 0.35088    | 0.35088    |   0.0 |  0.29
Other   |            | 0.0594     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134714.0 ave      134714 max      134714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134714
Ave neighs/atom = 67.357000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.117630219209, Press = -1.07671273336702
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  133000   -13449.765   -13449.765   -13533.905   -13533.905    325.63196    325.63196     31357.04     31357.04   -2212.4916   -2212.4916 
  134000   -13444.575   -13444.575   -13531.097   -13531.097    334.84825    334.84825    31341.092    31341.092   -449.67478   -449.67478 
Loop time of 119.052 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.070 hours/ns, 8.400 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.55     | 118.55     | 118.55     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095095   | 0.095095   | 0.095095   |   0.0 |  0.08
Output  | 0.00015464 | 0.00015464 | 0.00015464 |   0.0 |  0.00
Modify  | 0.35108    | 0.35108    | 0.35108    |   0.0 |  0.29
Other   |            | 0.05853    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134186.0 ave      134186 max      134186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134186
Ave neighs/atom = 67.093000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.102856728317, Press = -1.19820974396025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  134000   -13444.575   -13444.575   -13531.097   -13531.097    334.84825    334.84825    31341.092    31341.092   -449.67478   -449.67478 
  135000   -13445.893   -13445.893   -13532.178   -13532.178    333.93436    333.93436    31325.724    31325.724     532.6622     532.6622 
Loop time of 119.104 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.084 hours/ns, 8.396 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.6      | 118.6      | 118.6      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094898   | 0.094898   | 0.094898   |   0.0 |  0.08
Output  | 0.00015474 | 0.00015474 | 0.00015474 |   0.0 |  0.00
Modify  | 0.34889    | 0.34889    | 0.34889    |   0.0 |  0.29
Other   |            | 0.0594     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134788.0 ave      134788 max      134788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134788
Ave neighs/atom = 67.394000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.085940342508, Press = -0.970968186366847
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  135000   -13445.893   -13445.893   -13532.178   -13532.178    333.93436    333.93436    31325.724    31325.724     532.6622     532.6622 
  136000   -13447.808   -13447.808   -13531.228   -13531.228    322.84355    322.84355    31329.252    31329.252    383.86906    383.86906 
Loop time of 119.518 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.199 hours/ns, 8.367 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.01     | 119.01     | 119.01     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095729   | 0.095729   | 0.095729   |   0.0 |  0.08
Output  | 0.00015362 | 0.00015362 | 0.00015362 |   0.0 |  0.00
Modify  | 0.35028    | 0.35028    | 0.35028    |   0.0 |  0.29
Other   |            | 0.05867    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135054.0 ave      135054 max      135054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135054
Ave neighs/atom = 67.527000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.090177815764, Press = -0.929507230192137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  136000   -13447.808   -13447.808   -13531.228   -13531.228    322.84355    322.84355    31329.252    31329.252    383.86906    383.86906 
  137000   -13444.957   -13444.957   -13529.894   -13529.894    328.71306    328.71306    31340.778    31340.778   -199.79713   -199.79713 
Loop time of 119.476 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.188 hours/ns, 8.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.97     | 118.97     | 118.97     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094689   | 0.094689   | 0.094689   |   0.0 |  0.08
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.35151    | 0.35151    | 0.35151    |   0.0 |  0.29
Other   |            | 0.05885    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134962.0 ave      134962 max      134962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134962
Ave neighs/atom = 67.481000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.083254102011, Press = -0.991946787975812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  137000   -13444.957   -13444.957   -13529.894   -13529.894    328.71306    328.71306    31340.778    31340.778   -199.79713   -199.79713 
  138000   -13448.559   -13448.559   -13531.212   -13531.212    319.87707    319.87707    31340.543    31340.543   -578.48983   -578.48983 
Loop time of 113.974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.660 hours/ns, 8.774 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.48     | 113.48     | 113.48     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092422   | 0.092422   | 0.092422   |   0.0 |  0.08
Output  | 0.00014701 | 0.00014701 | 0.00014701 |   0.0 |  0.00
Modify  | 0.34052    | 0.34052    | 0.34052    |   0.0 |  0.30
Other   |            | 0.05793    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134900.0 ave      134900 max      134900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134900
Ave neighs/atom = 67.450000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.063296122066, Press = -1.06088250528142
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  138000   -13448.559   -13448.559   -13531.212   -13531.212    319.87707    319.87707    31340.543    31340.543   -578.48983   -578.48983 
  139000    -13443.72    -13443.72   -13530.748   -13530.748    336.80605    336.80605    31332.279    31332.279    267.65785    267.65785 
Loop time of 115.367 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.749 ns/day, 32.046 hours/ns, 8.668 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.87     | 114.87     | 114.87     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092051   | 0.092051   | 0.092051   |   0.0 |  0.08
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.34311    | 0.34311    | 0.34311    |   0.0 |  0.30
Other   |            | 0.05812    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134822.0 ave      134822 max      134822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134822
Ave neighs/atom = 67.411000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.050906029522, Press = -1.15732867591672
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  139000    -13443.72    -13443.72   -13530.748   -13530.748    336.80605    336.80605    31332.279    31332.279    267.65785    267.65785 
  140000   -13447.324   -13447.324   -13533.374   -13533.374    333.02536    333.02536    31307.719    31307.719    1953.1231    1953.1231 
Loop time of 119.348 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.152 hours/ns, 8.379 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.84     | 118.84     | 118.84     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094706   | 0.094706   | 0.094706   |   0.0 |  0.08
Output  | 0.00015343 | 0.00015343 | 0.00015343 |   0.0 |  0.00
Modify  | 0.35031    | 0.35031    | 0.35031    |   0.0 |  0.29
Other   |            | 0.05986    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135128.0 ave      135128 max      135128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135128
Ave neighs/atom = 67.564000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.045220563082, Press = -1.01895150918905
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  140000   -13447.324   -13447.324   -13533.374   -13533.374    333.02536    333.02536    31307.719    31307.719    1953.1231    1953.1231 
  141000   -13445.565   -13445.565   -13532.533   -13532.533    336.57433    336.57433     31323.63     31323.63    711.34786    711.34786 
Loop time of 119.232 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.120 hours/ns, 8.387 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.73     | 118.73     | 118.73     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094677   | 0.094677   | 0.094677   |   0.0 |  0.08
Output  | 0.00015446 | 0.00015446 | 0.00015446 |   0.0 |  0.00
Modify  | 0.35118    | 0.35118    | 0.35118    |   0.0 |  0.29
Other   |            | 0.05873    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135064.0 ave      135064 max      135064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135064
Ave neighs/atom = 67.532000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.027591035962, Press = -0.560072288850424
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  141000   -13445.565   -13445.565   -13532.533   -13532.533    336.57433    336.57433     31323.63     31323.63    711.34786    711.34786 
  142000   -13443.292   -13443.292   -13531.321   -13531.321    340.68151    340.68151    31382.183    31382.183   -4044.7295   -4044.7295 
Loop time of 119.244 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.123 hours/ns, 8.386 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    | 118.74     | 118.74     | 118.74     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094162   | 0.094162   | 0.094162   |   0.0 |  0.08
Output  | 0.00015344 | 0.00015344 | 0.00015344 |   0.0 |  0.00
Modify  | 0.3517     | 0.3517     | 0.3517     |   0.0 |  0.29
Other   |            | 0.05885    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134880.0 ave      134880 max      134880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134880
Ave neighs/atom = 67.440000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.023625981302, Press = -0.604111500156572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  142000   -13443.292   -13443.292   -13531.321   -13531.321    340.68151    340.68151    31382.183    31382.183   -4044.7295   -4044.7295 
  143000   -13449.575   -13449.575    -13531.64    -13531.64    317.59946    317.59946     31352.14     31352.14   -1741.7628   -1741.7628 
Loop time of 118.876 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.021 hours/ns, 8.412 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    | 118.37     | 118.37     | 118.37     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094746   | 0.094746   | 0.094746   |   0.0 |  0.08
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.35044    | 0.35044    | 0.35044    |   0.0 |  0.29
Other   |            | 0.05922    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134486.0 ave      134486 max      134486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134486
Ave neighs/atom = 67.243000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.006860304523, Press = -1.15296634843901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  143000   -13449.575   -13449.575    -13531.64    -13531.64    317.59946    317.59946     31352.14     31352.14   -1741.7628   -1741.7628 
  144000   -13445.231   -13445.231   -13532.735   -13532.735    338.64926    338.64926    31331.262    31331.262    181.56286    181.56286 
Loop time of 119.324 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.146 hours/ns, 8.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.82     | 118.82     | 118.82     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094966   | 0.094966   | 0.094966   |   0.0 |  0.08
Output  | 0.00015424 | 0.00015424 | 0.00015424 |   0.0 |  0.00
Modify  | 0.35131    | 0.35131    | 0.35131    |   0.0 |  0.29
Other   |            | 0.05882    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134692.0 ave      134692 max      134692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134692
Ave neighs/atom = 67.346000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.998367332736, Press = -1.07591219759689
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  144000   -13445.231   -13445.231   -13532.735   -13532.735    338.64926    338.64926    31331.262    31331.262    181.56286    181.56286 
  145000   -13441.738   -13441.738   -13531.686   -13531.686    348.10857    348.10857     31332.07     31332.07    321.75274    321.75274 
Loop time of 119.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.077 hours/ns, 8.398 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.57     | 118.57     | 118.57     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094623   | 0.094623   | 0.094623   |   0.0 |  0.08
Output  | 0.00046678 | 0.00046678 | 0.00046678 |   0.0 |  0.00
Modify  | 0.35239    | 0.35239    | 0.35239    |   0.0 |  0.30
Other   |            | 0.05877    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134798.0 ave      134798 max      134798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134798
Ave neighs/atom = 67.399000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.991084468962, Press = -0.918716499795504
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  145000   -13441.738   -13441.738   -13531.686   -13531.686    348.10857    348.10857     31332.07     31332.07    321.75274    321.75274 
  146000   -13446.039   -13446.039   -13531.323   -13531.323     330.0546     330.0546    31326.725    31326.725     600.3016     600.3016 
Loop time of 119.289 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.136 hours/ns, 8.383 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.78     | 118.78     | 118.78     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094412   | 0.094412   | 0.094412   |   0.0 |  0.08
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.35189    | 0.35189    | 0.35189    |   0.0 |  0.29
Other   |            | 0.05867    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135056.0 ave      135056 max      135056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135056
Ave neighs/atom = 67.528000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.99976740704, Press = -0.769910848422771
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  146000   -13446.039   -13446.039   -13531.323   -13531.323     330.0546     330.0546    31326.725    31326.725     600.3016     600.3016 
  147000   -13441.033   -13441.033   -13529.765   -13529.765    343.40033    343.40033    31362.608    31362.608   -1935.7562   -1935.7562 
Loop time of 119.314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.143 hours/ns, 8.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.81     | 118.81     | 118.81     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095044   | 0.095044   | 0.095044   |   0.0 |  0.08
Output  | 0.00015286 | 0.00015286 | 0.00015286 |   0.0 |  0.00
Modify  | 0.35095    | 0.35095    | 0.35095    |   0.0 |  0.29
Other   |            | 0.05934    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134948.0 ave      134948 max      134948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134948
Ave neighs/atom = 67.474000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.021825857967, Press = -0.831343904618098
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  147000   -13441.033   -13441.033   -13529.765   -13529.765    343.40033    343.40033    31362.608    31362.608   -1935.7562   -1935.7562 
  148000   -13445.393   -13445.393   -13531.666   -13531.666    333.88527    333.88527    31361.079    31361.079   -2306.5764   -2306.5764 
Loop time of 119.197 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.110 hours/ns, 8.389 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.69     | 118.69     | 118.69     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094858   | 0.094858   | 0.094858   |   0.0 |  0.08
Output  | 0.00015353 | 0.00015353 | 0.00015353 |   0.0 |  0.00
Modify  | 0.35201    | 0.35201    | 0.35201    |   0.0 |  0.30
Other   |            | 0.05907    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134862.0 ave      134862 max      134862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134862
Ave neighs/atom = 67.431000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.026962763016, Press = -1.32748327049941
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  148000   -13445.393   -13445.393   -13531.666   -13531.666    333.88527    333.88527    31361.079    31361.079   -2306.5764   -2306.5764 
  149000   -13447.184   -13447.184   -13531.829   -13531.829    327.58561    327.58561    31319.177    31319.177     968.7306     968.7306 
Loop time of 119.297 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.138 hours/ns, 8.382 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.79     | 118.79     | 118.79     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095206   | 0.095206   | 0.095206   |   0.0 |  0.08
Output  | 0.0001552  | 0.0001552  | 0.0001552  |   0.0 |  0.00
Modify  | 0.35164    | 0.35164    | 0.35164    |   0.0 |  0.29
Other   |            | 0.05877    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134430.0 ave      134430 max      134430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134430
Ave neighs/atom = 67.215000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.037050517999, Press = -1.22009691164238
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  149000   -13447.184   -13447.184   -13531.829   -13531.829    327.58561    327.58561    31319.177    31319.177     968.7306     968.7306 
  150000   -13445.214   -13445.214   -13531.484   -13531.484    333.87414    333.87414    31300.722    31300.722     2794.429     2794.429 
Loop time of 119.396 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.166 hours/ns, 8.375 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.89     | 118.89     | 118.89     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09489    | 0.09489    | 0.09489    |   0.0 |  0.08
Output  | 0.00015584 | 0.00015584 | 0.00015584 |   0.0 |  0.00
Modify  | 0.3515     | 0.3515     | 0.3515     |   0.0 |  0.29
Other   |            | 0.05928    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135118.0 ave      135118 max      135118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135118
Ave neighs/atom = 67.559000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.03470283085, Press = -0.768706871679287
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  150000   -13445.214   -13445.214   -13531.484   -13531.484    333.87414    333.87414    31300.722    31300.722     2794.429     2794.429 
  151000   -13447.601   -13447.601   -13533.039   -13533.039    330.65541    330.65541    31327.367    31327.367    254.69646    254.69646 
Loop time of 119.275 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.132 hours/ns, 8.384 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.77     | 118.77     | 118.77     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094364   | 0.094364   | 0.094364   |   0.0 |  0.08
Output  | 0.00019113 | 0.00019113 | 0.00019113 |   0.0 |  0.00
Modify  | 0.35234    | 0.35234    | 0.35234    |   0.0 |  0.30
Other   |            | 0.0588     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135168.0 ave      135168 max      135168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135168
Ave neighs/atom = 67.584000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.035876252173, Press = -0.323964461208802
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  151000   -13447.601   -13447.601   -13533.039   -13533.039    330.65541    330.65541    31327.367    31327.367    254.69646    254.69646 
  152000   -13445.024   -13445.024   -13532.005   -13532.005    336.62778    336.62778     31380.08     31380.08   -3956.9769   -3956.9769 
Loop time of 119.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.107 hours/ns, 8.390 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.68     | 118.68     | 118.68     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094816   | 0.094816   | 0.094816   |   0.0 |  0.08
Output  | 0.00019842 | 0.00019842 | 0.00019842 |   0.0 |  0.00
Modify  | 0.35261    | 0.35261    | 0.35261    |   0.0 |  0.30
Other   |            | 0.05872    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134820.0 ave      134820 max      134820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134820
Ave neighs/atom = 67.410000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.026854358671, Press = -0.71620327771722
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  152000   -13445.024   -13445.024   -13532.005   -13532.005    336.62778    336.62778     31380.08     31380.08   -3956.9769   -3956.9769 
  153000   -13447.826   -13447.826    -13533.02    -13533.02    329.71012    329.71012    31343.966    31343.966   -1000.2023   -1000.2023 
Loop time of 119.089 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.080 hours/ns, 8.397 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.58     | 118.58     | 118.58     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094907   | 0.094907   | 0.094907   |   0.0 |  0.08
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.35272    | 0.35272    | 0.35272    |   0.0 |  0.30
Other   |            | 0.05948    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134306.0 ave      134306 max      134306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134306
Ave neighs/atom = 67.153000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.019702790923, Press = -1.08806161318576
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  153000   -13447.826   -13447.826    -13533.02    -13533.02    329.71012    329.71012    31343.966    31343.966   -1000.2023   -1000.2023 
  154000   -13442.846   -13442.846   -13530.266   -13530.266    338.32377    338.32377    31329.197    31329.197    808.49139    808.49139 
Loop time of 119.319 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.144 hours/ns, 8.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.81     | 118.81     | 118.81     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09506    | 0.09506    | 0.09506    |   0.0 |  0.08
Output  | 0.00014861 | 0.00014861 | 0.00014861 |   0.0 |  0.00
Modify  | 0.35238    | 0.35238    | 0.35238    |   0.0 |  0.30
Other   |            | 0.05895    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134696.0 ave      134696 max      134696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134696
Ave neighs/atom = 67.348000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.012793372599, Press = -1.03332576629656
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  154000   -13442.846   -13442.846   -13530.266   -13530.266    338.32377    338.32377    31329.197    31329.197    808.49139    808.49139 
  155000   -13446.305   -13446.305   -13531.809   -13531.809    330.90737    330.90737    31314.216    31314.216    1674.5994    1674.5994 
Loop time of 119.372 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.159 hours/ns, 8.377 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.87     | 118.87     | 118.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094805   | 0.094805   | 0.094805   |   0.0 |  0.08
Output  | 0.0001527  | 0.0001527  | 0.0001527  |   0.0 |  0.00
Modify  | 0.35136    | 0.35136    | 0.35136    |   0.0 |  0.29
Other   |            | 0.05896    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135078.0 ave      135078 max      135078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135078
Ave neighs/atom = 67.539000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.013007421966, Press = -0.774278031436078
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  155000   -13446.305   -13446.305   -13531.809   -13531.809    330.90737    330.90737    31314.216    31314.216    1674.5994    1674.5994 
  156000   -13444.268   -13444.268   -13528.706   -13528.706    326.78628    326.78628    31329.748    31329.748    472.58484    472.58484 
Loop time of 119.39 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.164 hours/ns, 8.376 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.88     | 118.88     | 118.88     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094594   | 0.094594   | 0.094594   |   0.0 |  0.08
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.35197    | 0.35197    | 0.35197    |   0.0 |  0.29
Other   |            | 0.05928    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135138.0 ave      135138 max      135138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135138
Ave neighs/atom = 67.569000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.011209684148, Press = -0.33399452677496
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  156000   -13444.268   -13444.268   -13528.706   -13528.706    326.78628    326.78628    31329.748    31329.748    472.58484    472.58484 
  157000   -13446.328   -13446.328   -13532.844   -13532.844    334.82434    334.82434    31380.778    31380.778   -3949.4922   -3949.4922 
Loop time of 119.377 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.160 hours/ns, 8.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.87     | 118.87     | 118.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094753   | 0.094753   | 0.094753   |   0.0 |  0.08
Output  | 0.00019882 | 0.00019882 | 0.00019882 |   0.0 |  0.00
Modify  | 0.35229    | 0.35229    | 0.35229    |   0.0 |  0.30
Other   |            | 0.05903    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135060.0 ave      135060 max      135060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135060
Ave neighs/atom = 67.530000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.012268674277, Press = -0.675722302510477
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  157000   -13446.328   -13446.328   -13532.844   -13532.844    334.82434    334.82434    31380.778    31380.778   -3949.4922   -3949.4922 
  158000   -13442.311   -13442.311   -13529.996   -13529.996     339.3506     339.3506    31359.061    31359.061    -1661.041    -1661.041 
Loop time of 119.1 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.083 hours/ns, 8.396 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.6      | 118.6      | 118.6      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094788   | 0.094788   | 0.094788   |   0.0 |  0.08
Output  | 0.0001535  | 0.0001535  | 0.0001535  |   0.0 |  0.00
Modify  | 0.34935    | 0.34935    | 0.34935    |   0.0 |  0.29
Other   |            | 0.05933    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134270.0 ave      134270 max      134270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134270
Ave neighs/atom = 67.135000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.020799440264, Press = -1.17053685117378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  158000   -13442.311   -13442.311   -13529.996   -13529.996     339.3506     339.3506    31359.061    31359.061    -1661.041    -1661.041 
  159000   -13447.654   -13447.654   -13534.459   -13534.459    335.94341    335.94341    31317.612    31317.612    1081.9864    1081.9864 
Loop time of 119.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.161 hours/ns, 8.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.87     | 118.87     | 118.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094555   | 0.094555   | 0.094555   |   0.0 |  0.08
Output  | 0.0001548  | 0.0001548  | 0.0001548  |   0.0 |  0.00
Modify  | 0.35141    | 0.35141    | 0.35141    |   0.0 |  0.29
Other   |            | 0.05946    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134628.0 ave      134628 max      134628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134628
Ave neighs/atom = 67.314000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.025583090588, Press = -1.00992756109108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  159000   -13447.654   -13447.654   -13534.459   -13534.459    335.94341    335.94341    31317.612    31317.612    1081.9864    1081.9864 
  160000   -13442.276   -13442.276   -13528.225   -13528.225    332.63174    332.63174    31317.948    31317.948    2080.4031    2080.4031 
Loop time of 119.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.158 hours/ns, 8.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.87     | 118.87     | 118.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094796   | 0.094796   | 0.094796   |   0.0 |  0.08
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.35045    | 0.35045    | 0.35045    |   0.0 |  0.29
Other   |            | 0.05871    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134978.0 ave      134978 max      134978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134978
Ave neighs/atom = 67.489000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.031569515436, Press = -0.662461206206632
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  160000   -13442.276   -13442.276   -13528.225   -13528.225    332.63174    332.63174    31317.948    31317.948    2080.4031    2080.4031 
  161000    -13445.24    -13445.24   -13531.177   -13531.177    332.58664    332.58664    31334.526    31334.526    16.105803    16.105803 
Loop time of 119.327 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.146 hours/ns, 8.380 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.82     | 118.82     | 118.82     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094401   | 0.094401   | 0.094401   |   0.0 |  0.08
Output  | 0.00015369 | 0.00015369 | 0.00015369 |   0.0 |  0.00
Modify  | 0.35152    | 0.35152    | 0.35152    |   0.0 |  0.29
Other   |            | 0.05871    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135018.0 ave      135018 max      135018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135018
Ave neighs/atom = 67.509000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.029470900616, Press = -0.559499843896949
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  161000    -13445.24    -13445.24   -13531.177   -13531.177    332.58664    332.58664    31334.526    31334.526    16.105803    16.105803 
  162000   -13442.855   -13442.855    -13528.57    -13528.57    331.72585    331.72585    31403.902    31403.902   -5238.6252   -5238.6252 
Loop time of 119.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.182 hours/ns, 8.371 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.95     | 118.95     | 118.95     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094737   | 0.094737   | 0.094737   |   0.0 |  0.08
Output  | 0.00016093 | 0.00016093 | 0.00016093 |   0.0 |  0.00
Modify  | 0.3523     | 0.3523     | 0.3523     |   0.0 |  0.29
Other   |            | 0.05866    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134934.0 ave      134934 max      134934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134934
Ave neighs/atom = 67.467000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.023143476116, Press = -0.654864105307467
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  162000   -13442.855   -13442.855    -13528.57    -13528.57    331.72585    331.72585    31403.902    31403.902   -5238.6252   -5238.6252 
  163000   -13444.496   -13444.496   -13530.273   -13530.273    331.96481    331.96481    31365.056    31365.056   -2161.2323   -2161.2323 
Loop time of 119.059 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.072 hours/ns, 8.399 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.55     | 118.55     | 118.55     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094666   | 0.094666   | 0.094666   |   0.0 |  0.08
Output  | 0.000155   | 0.000155   | 0.000155   |   0.0 |  0.00
Modify  | 0.35262    | 0.35262    | 0.35262    |   0.0 |  0.30
Other   |            | 0.05902    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134224.0 ave      134224 max      134224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134224
Ave neighs/atom = 67.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.031363665165, Press = -1.17071960518526
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  163000   -13444.496   -13444.496   -13530.273   -13530.273    331.96481    331.96481    31365.056    31365.056   -2161.2323   -2161.2323 
  164000   -13444.778   -13444.778   -13531.312   -13531.312     334.8967     334.8967    31321.222    31321.222    1016.7218    1016.7218 
Loop time of 118.978 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.050 hours/ns, 8.405 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.47     | 118.47     | 118.47     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094373   | 0.094373   | 0.094373   |   0.0 |  0.08
Output  | 0.00015519 | 0.00015519 | 0.00015519 |   0.0 |  0.00
Modify  | 0.3512     | 0.3512     | 0.3512     |   0.0 |  0.30
Other   |            | 0.05821    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134348.0 ave      134348 max      134348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134348
Ave neighs/atom = 67.174000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.053088482264, Press = -0.966103867992127
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  164000   -13444.778   -13444.778   -13531.312   -13531.312     334.8967     334.8967    31321.222    31321.222    1016.7218    1016.7218 
  165000   -13443.301   -13443.301   -13530.129   -13530.129    336.03398    336.03398    31321.875    31321.875    1318.9123    1318.9123 
Loop time of 119.522 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.201 hours/ns, 8.367 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.02     | 119.02     | 119.02     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094534   | 0.094534   | 0.094534   |   0.0 |  0.08
Output  | 0.00015467 | 0.00015467 | 0.00015467 |   0.0 |  0.00
Modify  | 0.35156    | 0.35156    | 0.35156    |   0.0 |  0.29
Other   |            | 0.05901    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135212.0 ave      135212 max      135212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135212
Ave neighs/atom = 67.606000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.056152466798, Press = -0.675825900420578
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  165000   -13443.301   -13443.301   -13530.129   -13530.129    336.03398    336.03398    31321.875    31321.875    1318.9123    1318.9123 
  166000   -13446.599   -13446.599   -13530.572   -13530.572    324.98355    324.98355    31338.836    31338.836    -307.2391    -307.2391 
Loop time of 119.428 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.174 hours/ns, 8.373 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.92     | 118.92     | 118.92     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095391   | 0.095391   | 0.095391   |   0.0 |  0.08
Output  | 0.00015255 | 0.00015255 | 0.00015255 |   0.0 |  0.00
Modify  | 0.35171    | 0.35171    | 0.35171    |   0.0 |  0.29
Other   |            | 0.05866    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135064.0 ave      135064 max      135064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135064
Ave neighs/atom = 67.532000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.069601282772, Press = -0.513485185017383
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  166000   -13446.599   -13446.599   -13530.572   -13530.572    324.98355    324.98355    31338.836    31338.836    -307.2391    -307.2391 
  167000   -13442.606   -13442.606     -13530.9     -13530.9     341.7084     341.7084    31408.741    31408.741   -6261.4749   -6261.4749 
Loop time of 119.45 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.181 hours/ns, 8.372 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.95     | 118.95     | 118.95     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095113   | 0.095113   | 0.095113   |   0.0 |  0.08
Output  | 0.00015458 | 0.00015458 | 0.00015458 |   0.0 |  0.00
Modify  | 0.35144    | 0.35144    | 0.35144    |   0.0 |  0.29
Other   |            | 0.05852    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134864.0 ave      134864 max      134864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134864
Ave neighs/atom = 67.432000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.082822872127, Press = -0.75430598766599
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  167000   -13442.606   -13442.606     -13530.9     -13530.9     341.7084     341.7084    31408.741    31408.741   -6261.4749   -6261.4749 
  168000   -13446.037   -13446.037   -13531.852   -13531.852    332.11269    332.11269    31351.091    31351.091   -1441.1444   -1441.1444 
Loop time of 119.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.110 hours/ns, 8.389 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    | 118.69     | 118.69     | 118.69     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095168   | 0.095168   | 0.095168   |   0.0 |  0.08
Output  | 0.000153   | 0.000153   | 0.000153   |   0.0 |  0.00
Modify  | 0.351      | 0.351      | 0.351      |   0.0 |  0.29
Other   |            | 0.05915    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134226.0 ave      134226 max      134226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134226
Ave neighs/atom = 67.113000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.100557810872, Press = -1.14280703560407
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  168000   -13446.037   -13446.037   -13531.852   -13531.852    332.11269    332.11269    31351.091    31351.091   -1441.1444   -1441.1444 
  169000   -13441.597   -13441.597   -13530.461   -13530.461      343.913      343.913    31314.969    31314.969    1921.8122    1921.8122 
Loop time of 119.368 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.158 hours/ns, 8.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.86     | 118.86     | 118.86     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094911   | 0.094911   | 0.094911   |   0.0 |  0.08
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.35101    | 0.35101    | 0.35101    |   0.0 |  0.29
Other   |            | 0.05902    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134616.0 ave      134616 max      134616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134616
Ave neighs/atom = 67.308000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.106830663278, Press = -0.843480320752515
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  169000   -13441.597   -13441.597   -13530.461   -13530.461      343.913      343.913    31314.969    31314.969    1921.8122    1921.8122 
  170000   -13445.269   -13445.269   -13533.601   -13533.601    341.85392    341.85392    31312.355    31312.355    1579.9609    1579.9609 
Loop time of 119.543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.206 hours/ns, 8.365 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.04     | 119.04     | 119.04     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094555   | 0.094555   | 0.094555   |   0.0 |  0.08
Output  | 0.00020021 | 0.00020021 | 0.00020021 |   0.0 |  0.00
Modify  | 0.35079    | 0.35079    | 0.35079    |   0.0 |  0.29
Other   |            | 0.05913    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135116.0 ave      135116 max      135116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135116
Ave neighs/atom = 67.558000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.114498022948, Press = -0.574238411786933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  170000   -13445.269   -13445.269   -13533.601   -13533.601    341.85392    341.85392    31312.355    31312.355    1579.9609    1579.9609 
  171000   -13447.389   -13447.389   -13530.443   -13530.443    321.42523    321.42523    31333.741    31333.741     144.3603     144.3603 
Loop time of 119.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.128 hours/ns, 8.385 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.75     | 118.75     | 118.75     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094865   | 0.094865   | 0.094865   |   0.0 |  0.08
Output  | 0.00046763 | 0.00046763 | 0.00046763 |   0.0 |  0.00
Modify  | 0.3507     | 0.3507     | 0.3507     |   0.0 |  0.29
Other   |            | 0.05911    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134820.0 ave      134820 max      134820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134820
Ave neighs/atom = 67.410000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.114900436097, Press = -0.393273651070523
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  171000   -13447.389   -13447.389   -13530.443   -13530.443    321.42523    321.42523    31333.741    31333.741     144.3603     144.3603 
  172000   -13445.047   -13445.047    -13529.08    -13529.08    325.21553    325.21553    31386.424    31386.424   -4078.2579   -4078.2579 
Loop time of 119.246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.124 hours/ns, 8.386 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.74     | 118.74     | 118.74     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094642   | 0.094642   | 0.094642   |   0.0 |  0.08
Output  | 0.0001545  | 0.0001545  | 0.0001545  |   0.0 |  0.00
Modify  | 0.35108    | 0.35108    | 0.35108    |   0.0 |  0.29
Other   |            | 0.05968    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134800.0 ave      134800 max      134800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134800
Ave neighs/atom = 67.400000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.112883503792, Press = -0.669208356276587
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  172000   -13445.047   -13445.047    -13529.08    -13529.08    325.21553    325.21553    31386.424    31386.424   -4078.2579   -4078.2579 
  173000   -13448.212   -13448.212   -13532.645   -13532.645    326.76661    326.76661    31356.043    31356.043   -2000.3573   -2000.3573 
Loop time of 119.116 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.088 hours/ns, 8.395 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.61     | 118.61     | 118.61     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095685   | 0.095685   | 0.095685   |   0.0 |  0.08
Output  | 0.00015518 | 0.00015518 | 0.00015518 |   0.0 |  0.00
Modify  | 0.35169    | 0.35169    | 0.35169    |   0.0 |  0.30
Other   |            | 0.05869    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134308.0 ave      134308 max      134308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134308
Ave neighs/atom = 67.154000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.105233162823, Press = -1.25074963421001
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  173000   -13448.212   -13448.212   -13532.645   -13532.645    326.76661    326.76661    31356.043    31356.043   -2000.3573   -2000.3573 
  174000   -13442.747   -13442.747   -13530.919   -13530.919    341.23476    341.23476    31318.934    31318.934    1458.8807    1458.8807 
Loop time of 119.385 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.162 hours/ns, 8.376 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.88     | 118.88     | 118.88     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095041   | 0.095041   | 0.095041   |   0.0 |  0.08
Output  | 0.00020273 | 0.00020273 | 0.00020273 |   0.0 |  0.00
Modify  | 0.35126    | 0.35126    | 0.35126    |   0.0 |  0.29
Other   |            | 0.05893    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134580.0 ave      134580 max      134580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134580
Ave neighs/atom = 67.290000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.090173076058, Press = -0.797032033906431
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  174000   -13442.747   -13442.747   -13530.919   -13530.919    341.23476    341.23476    31318.934    31318.934    1458.8807    1458.8807 
  175000   -13448.386   -13448.386    -13532.43    -13532.43    325.25765    325.25765    31309.045    31309.045    1926.1177    1926.1177 
Loop time of 119.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.135 hours/ns, 8.383 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.78     | 118.78     | 118.78     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095249   | 0.095249   | 0.095249   |   0.0 |  0.08
Output  | 0.00015301 | 0.00015301 | 0.00015301 |   0.0 |  0.00
Modify  | 0.35066    | 0.35066    | 0.35066    |   0.0 |  0.29
Other   |            | 0.05922    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135088.0 ave      135088 max      135088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135088
Ave neighs/atom = 67.544000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.085468848504, Press = -0.572732937257188
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  175000   -13448.386   -13448.386    -13532.43    -13532.43    325.25765    325.25765    31309.045    31309.045    1926.1177    1926.1177 
  176000   -13445.967   -13445.967   -13532.674   -13532.674    335.56285    335.56285    31334.386    31334.386   -98.405302   -98.405302 
Loop time of 119.363 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.156 hours/ns, 8.378 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.86     | 118.86     | 118.86     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094914   | 0.094914   | 0.094914   |   0.0 |  0.08
Output  | 0.00019902 | 0.00019902 | 0.00019902 |   0.0 |  0.00
Modify  | 0.35116    | 0.35116    | 0.35116    |   0.0 |  0.29
Other   |            | 0.05922    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135050.0 ave      135050 max      135050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135050
Ave neighs/atom = 67.525000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.08289328648, Press = -0.456723903568649
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  176000   -13445.967   -13445.967   -13532.674   -13532.674    335.56285    335.56285    31334.386    31334.386   -98.405302   -98.405302 
  177000   -13445.848   -13445.848   -13533.131   -13533.131    337.79328    337.79328    31379.334    31379.334   -3821.1653   -3821.1653 
Loop time of 119.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.137 hours/ns, 8.383 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.79     | 118.79     | 118.79     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094686   | 0.094686   | 0.094686   |   0.0 |  0.08
Output  | 0.00020113 | 0.00020113 | 0.00020113 |   0.0 |  0.00
Modify  | 0.35105    | 0.35105    | 0.35105    |   0.0 |  0.29
Other   |            | 0.05892    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134758.0 ave      134758 max      134758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134758
Ave neighs/atom = 67.379000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.060550982466, Press = -0.646715974512945
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  177000   -13445.848   -13445.848   -13533.131   -13533.131    337.79328    337.79328    31379.334    31379.334   -3821.1653   -3821.1653 
  178000   -13447.524   -13447.524   -13531.906   -13531.906    326.56502    326.56502    31362.822    31362.822   -2060.1809   -2060.1809 
Loop time of 118.996 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.054 hours/ns, 8.404 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    | 118.49     | 118.49     | 118.49     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093933   | 0.093933   | 0.093933   |   0.0 |  0.08
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.35036    | 0.35036    | 0.35036    |   0.0 |  0.29
Other   |            | 0.05938    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134334.0 ave      134334 max      134334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134334
Ave neighs/atom = 67.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.057984258347, Press = -1.15579627448672
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  178000   -13447.524   -13447.524   -13531.906   -13531.906    326.56502    326.56502    31362.822    31362.822   -2060.1809   -2060.1809 
  179000   -13444.829   -13444.829     -13531.9     -13531.9    336.97531    336.97531    31320.915    31320.915    1360.3717    1360.3717 
Loop time of 119.304 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.140 hours/ns, 8.382 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    | 118.8      | 118.8      | 118.8      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094616   | 0.094616   | 0.094616   |   0.0 |  0.08
Output  | 0.00015481 | 0.00015481 | 0.00015481 |   0.0 |  0.00
Modify  | 0.35103    | 0.35103    | 0.35103    |   0.0 |  0.29
Other   |            | 0.05938    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134294.0 ave      134294 max      134294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134294
Ave neighs/atom = 67.147000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.03785920629, Press = -0.788835892382028
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  179000   -13444.829   -13444.829     -13531.9     -13531.9    336.97531    336.97531    31320.915    31320.915    1360.3717    1360.3717 
  180000   -13448.403   -13448.403   -13532.749   -13532.749    326.43029    326.43029    31314.322    31314.322    1447.6942    1447.6942 
Loop time of 119.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.169 hours/ns, 8.375 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    | 118.9      | 118.9      | 118.9      |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09572    | 0.09572    | 0.09572    |   0.0 |  0.08
Output  | 0.0001976  | 0.0001976  | 0.0001976  |   0.0 |  0.00
Modify  | 0.35353    | 0.35353    | 0.35353    |   0.0 |  0.30
Other   |            | 0.05862    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135074.0 ave      135074 max      135074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135074
Ave neighs/atom = 67.537000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.035300975669, Press = -0.602930294845589
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  180000   -13448.403   -13448.403   -13532.749   -13532.749    326.43029    326.43029    31314.322    31314.322    1447.6942    1447.6942 
  181000   -13445.391   -13445.391   -13532.094   -13532.094    335.54894    335.54894    31331.683    31331.683    226.37597    226.37597 
Loop time of 119.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.177 hours/ns, 8.373 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    | 118.93     | 118.93     | 118.93     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094539   | 0.094539   | 0.094539   |   0.0 |  0.08
Output  | 0.00015199 | 0.00015199 | 0.00015199 |   0.0 |  0.00
Modify  | 0.35159    | 0.35159    | 0.35159    |   0.0 |  0.29
Other   |            | 0.05925    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134976.0 ave      134976 max      134976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134976
Ave neighs/atom = 67.488000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.039437222918, Press = -0.451509606038243
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  181000   -13445.391   -13445.391   -13532.094   -13532.094    335.54894    335.54894    31331.683    31331.683    226.37597    226.37597 
  182000   -13442.691   -13442.691   -13529.466   -13529.466    335.82995    335.82995    31367.906    31367.906   -2294.4726   -2294.4726 
Loop time of 119.044 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.068 hours/ns, 8.400 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    | 118.54     | 118.54     | 118.54     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094725   | 0.094725   | 0.094725   |   0.0 |  0.08
Output  | 0.00015335 | 0.00015335 | 0.00015335 |   0.0 |  0.00
Modify  | 0.35197    | 0.35197    | 0.35197    |   0.0 |  0.30
Other   |            | 0.05889    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134904.0 ave      134904 max      134904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134904
Ave neighs/atom = 67.452000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.052051830445, Press = -0.546317917421755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  182000   -13442.691   -13442.691   -13529.466   -13529.466    335.82995    335.82995    31367.906    31367.906   -2294.4726   -2294.4726 
  183000   -13448.991   -13448.991   -13533.745   -13533.745    328.00626    328.00626    31374.354    31374.354   -3569.3919   -3569.3919 
Loop time of 119.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.091 hours/ns, 8.394 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    | 118.62     | 118.62     | 118.62     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095944   | 0.095944   | 0.095944   |   0.0 |  0.08
Output  | 0.00019652 | 0.00019652 | 0.00019652 |   0.0 |  0.00
Modify  | 0.35199    | 0.35199    | 0.35199    |   0.0 |  0.30
Other   |            | 0.05947    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134466.0 ave      134466 max      134466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134466
Ave neighs/atom = 67.233000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.047592915122, Press = -0.987050248589155
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  183000   -13448.991   -13448.991   -13533.745   -13533.745    328.00626    328.00626    31374.354    31374.354   -3569.3919   -3569.3919 
  184000   -13443.983   -13443.983   -13532.106   -13532.106    341.04312    341.04312    31324.872    31324.872    1033.1035    1033.1035 
Loop time of 118.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.034 hours/ns, 8.409 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.41     | 118.41     | 118.41     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094839   | 0.094839   | 0.094839   |   0.0 |  0.08
Output  | 0.00015303 | 0.00015303 | 0.00015303 |   0.0 |  0.00
Modify  | 0.35198    | 0.35198    | 0.35198    |   0.0 |  0.30
Other   |            | 0.05933    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134182.0 ave      134182 max      134182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134182
Ave neighs/atom = 67.091000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.036596124743, Press = -1.00498229448674
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  184000   -13443.983   -13443.983   -13532.106   -13532.106    341.04312    341.04312    31324.872    31324.872    1033.1035    1033.1035 
  185000   -13449.574   -13449.574    -13531.56    -13531.56     317.2935     317.2935    31301.008    31301.008    2781.1449    2781.1449 
Loop time of 119.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.151 hours/ns, 8.379 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    | 118.84     | 118.84     | 118.84     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095623   | 0.095623   | 0.095623   |   0.0 |  0.08
Output  | 0.00015685 | 0.00015685 | 0.00015685 |   0.0 |  0.00
Modify  | 0.35289    | 0.35289    | 0.35289    |   0.0 |  0.30
Other   |            | 0.05915    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134788.0 ave      134788 max      134788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134788
Ave neighs/atom = 67.394000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.03536942151, Press = -0.578761943795577
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  185000   -13449.574   -13449.574    -13531.56    -13531.56     317.2935     317.2935    31301.008    31301.008    2781.1449    2781.1449 
  186000   -13444.926   -13444.926   -13530.269   -13530.269    330.28654    330.28654    31332.087    31332.087    228.17159    228.17159 
Loop time of 119.426 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.174 hours/ns, 8.373 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    | 118.92     | 118.92     | 118.92     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09482    | 0.09482    | 0.09482    |   0.0 |  0.08
Output  | 0.00020592 | 0.00020592 | 0.00020592 |   0.0 |  0.00
Modify  | 0.35153    | 0.35153    | 0.35153    |   0.0 |  0.29
Other   |            | 0.05912    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135208.0 ave      135208 max      135208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135208
Ave neighs/atom = 67.604000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.017666590658, Press = -0.345209178215455
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  186000   -13444.926   -13444.926   -13530.269   -13530.269    330.28654    330.28654    31332.087    31332.087    228.17159    228.17159 
  187000   -13448.584   -13448.584   -13531.452   -13531.452    320.70735    320.70735    31361.739    31361.739   -2497.1273   -2497.1273 
Loop time of 119.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.135 hours/ns, 8.383 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.78     | 118.78     | 118.78     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09491    | 0.09491    | 0.09491    |   0.0 |  0.08
Output  | 0.00015165 | 0.00015165 | 0.00015165 |   0.0 |  0.00
Modify  | 0.3516     | 0.3516     | 0.3516     |   0.0 |  0.29
Other   |            | 0.05888    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134974.0 ave      134974 max      134974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134974
Ave neighs/atom = 67.487000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.013204482586, Press = -0.502499569764408
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  187000   -13448.584   -13448.584   -13531.452   -13531.452    320.70735    320.70735    31361.739    31361.739   -2497.1273   -2497.1273 
  188000    -13442.66    -13442.66   -13529.594   -13529.594    336.44138    336.44138     31364.48     31364.48   -2096.9908   -2096.9908 
Loop time of 119.166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.102 hours/ns, 8.392 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.66     | 118.66     | 118.66     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094253   | 0.094253   | 0.094253   |   0.0 |  0.08
Output  | 0.00015251 | 0.00015251 | 0.00015251 |   0.0 |  0.00
Modify  | 0.35215    | 0.35215    | 0.35215    |   0.0 |  0.30
Other   |            | 0.05949    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134570.0 ave      134570 max      134570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134570
Ave neighs/atom = 67.285000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.012394993896, Press = -0.804906743396461
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  188000    -13442.66    -13442.66   -13529.594   -13529.594    336.44138    336.44138     31364.48     31364.48   -2096.9908   -2096.9908 
  189000   -13447.084   -13447.084   -13531.656   -13531.656    327.30101    327.30101    31315.792    31315.792    1630.6697    1630.6697 
Loop time of 119.244 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.123 hours/ns, 8.386 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.74     | 118.74     | 118.74     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095666   | 0.095666   | 0.095666   |   0.0 |  0.08
Output  | 0.00015495 | 0.00015495 | 0.00015495 |   0.0 |  0.00
Modify  | 0.35191    | 0.35191    | 0.35191    |   0.0 |  0.30
Other   |            | 0.05861    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134716.0 ave      134716 max      134716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134716
Ave neighs/atom = 67.358000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.025773064772, Press = -0.855628242762382
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  189000   -13447.084   -13447.084   -13531.656   -13531.656    327.30101    327.30101    31315.792    31315.792    1630.6697    1630.6697 
  190000   -13443.994   -13443.994   -13530.605   -13530.605    335.19318    335.19318    31295.896    31295.896    3520.7721    3520.7721 
Loop time of 119.27 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.131 hours/ns, 8.384 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.76     | 118.76     | 118.76     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095495   | 0.095495   | 0.095495   |   0.0 |  0.08
Output  | 0.00015535 | 0.00015535 | 0.00015535 |   0.0 |  0.00
Modify  | 0.35197    | 0.35197    | 0.35197    |   0.0 |  0.30
Other   |            | 0.05892    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135086.0 ave      135086 max      135086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135086
Ave neighs/atom = 67.543000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.031990104556, Press = -0.43353670025355
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  190000   -13443.994   -13443.994   -13530.605   -13530.605    335.19318    335.19318    31295.896    31295.896    3520.7721    3520.7721 
  191000   -13447.849   -13447.849    -13532.58    -13532.58     327.9173     327.9173    31330.252    31330.252    218.92707    218.92707 
Loop time of 119.552 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.209 hours/ns, 8.365 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.05     | 119.05     | 119.05     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095423   | 0.095423   | 0.095423   |   0.0 |  0.08
Output  | 0.00015231 | 0.00015231 | 0.00015231 |   0.0 |  0.00
Modify  | 0.35124    | 0.35124    | 0.35124    |   0.0 |  0.29
Other   |            | 0.05933    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135502.0 ave      135502 max      135502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135502
Ave neighs/atom = 67.751000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.030149936604, Press = -0.226143497161644
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  191000   -13447.849   -13447.849    -13532.58    -13532.58     327.9173     327.9173    31330.252    31330.252    218.92707    218.92707 
  192000   -13443.429   -13443.429   -13529.446   -13529.446    332.89792    332.89792     31360.32     31360.32   -1797.7477   -1797.7477 
Loop time of 119.175 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.104 hours/ns, 8.391 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.67     | 118.67     | 118.67     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094108   | 0.094108   | 0.094108   |   0.0 |  0.08
Output  | 0.0001545  | 0.0001545  | 0.0001545  |   0.0 |  0.00
Modify  | 0.34958    | 0.34958    | 0.34958    |   0.0 |  0.29
Other   |            | 0.05905    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134914.0 ave      134914 max      134914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134914
Ave neighs/atom = 67.457000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.019848917096, Press = -0.493409334196483
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  192000   -13443.429   -13443.429   -13529.446   -13529.446    332.89792    332.89792     31360.32     31360.32   -1797.7477   -1797.7477 
  193000   -13448.681   -13448.681   -13534.816   -13534.816    333.35095    333.35095    31342.684    31342.684   -1094.7142   -1094.7142 
Loop time of 119.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.081 hours/ns, 8.397 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.59     | 118.59     | 118.59     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092906   | 0.092906   | 0.092906   |   0.0 |  0.08
Output  | 0.00015219 | 0.00015219 | 0.00015219 |   0.0 |  0.00
Modify  | 0.34778    | 0.34778    | 0.34778    |   0.0 |  0.29
Other   |            | 0.05964    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134586.0 ave      134586 max      134586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134586
Ave neighs/atom = 67.293000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.005366281972, Press = -0.65248293560864
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  193000   -13448.681   -13448.681   -13534.816   -13534.816    333.35095    333.35095    31342.684    31342.684   -1094.7142   -1094.7142 
  194000   -13445.833   -13445.833   -13530.551   -13530.551     327.8684     327.8684    31327.987    31327.987    669.83774    669.83774 
Loop time of 118.982 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.050 hours/ns, 8.405 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.48     | 118.48     | 118.48     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09352    | 0.09352    | 0.09352    |   0.0 |  0.08
Output  | 0.00015337 | 0.00015337 | 0.00015337 |   0.0 |  0.00
Modify  | 0.3509     | 0.3509     | 0.3509     |   0.0 |  0.29
Other   |            | 0.0592     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134554.0 ave      134554 max      134554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134554
Ave neighs/atom = 67.277000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.000358285577, Press = -0.659639387663215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  194000   -13445.833   -13445.833   -13530.551   -13530.551     327.8684     327.8684    31327.987    31327.987    669.83774    669.83774 
  195000   -13445.651   -13445.651   -13530.809   -13530.809    329.56907    329.56907    31318.738    31318.738    1289.3715    1289.3715 
Loop time of 119.261 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.128 hours/ns, 8.385 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.76     | 118.76     | 118.76     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093681   | 0.093681   | 0.093681   |   0.0 |  0.08
Output  | 0.00015183 | 0.00015183 | 0.00015183 |   0.0 |  0.00
Modify  | 0.34861    | 0.34861    | 0.34861    |   0.0 |  0.29
Other   |            | 0.0589     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135224.0 ave      135224 max      135224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135224
Ave neighs/atom = 67.612000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.992827457983, Press = -0.478461979281221
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  195000   -13445.651   -13445.651   -13530.809   -13530.809    329.56907    329.56907    31318.738    31318.738    1289.3715    1289.3715 
  196000   -13449.353   -13449.353   -13533.715   -13533.715    326.48887    326.48887    31343.152    31343.152   -1354.5788   -1354.5788 
Loop time of 119.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.093 hours/ns, 8.394 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.63     | 118.63     | 118.63     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094008   | 0.094008   | 0.094008   |   0.0 |  0.08
Output  | 0.00015263 | 0.00015263 | 0.00015263 |   0.0 |  0.00
Modify  | 0.34985    | 0.34985    | 0.34985    |   0.0 |  0.29
Other   |            | 0.05929    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      135086.0 ave      135086 max      135086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135086
Ave neighs/atom = 67.543000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.984274129537, Press = -0.201047585140044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  196000   -13449.353   -13449.353   -13533.715   -13533.715    326.48887    326.48887    31343.152    31343.152   -1354.5788   -1354.5788 
  197000   -13443.421   -13443.421   -13531.082   -13531.082    339.25739    339.25739    31387.588    31387.588   -4179.3783   -4179.3783 
Loop time of 118.813 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.003 hours/ns, 8.417 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.31     | 118.31     | 118.31     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093099   | 0.093099   | 0.093099   |   0.0 |  0.08
Output  | 0.00015514 | 0.00015514 | 0.00015514 |   0.0 |  0.00
Modify  | 0.34824    | 0.34824    | 0.34824    |   0.0 |  0.29
Other   |            | 0.05961    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134716.0 ave      134716 max      134716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134716
Ave neighs/atom = 67.358000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.973356216155, Press = -0.578261940211325
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  197000   -13443.421   -13443.421   -13531.082   -13531.082    339.25739    339.25739    31387.588    31387.588   -4179.3783   -4179.3783 
  198000   -13447.947   -13447.947   -13533.402   -13533.402    330.72099    330.72099    31343.459    31343.459   -853.92617   -853.92617 
Loop time of 119.018 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.061 hours/ns, 8.402 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.52     | 118.52     | 118.52     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093166   | 0.093166   | 0.093166   |   0.0 |  0.08
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.34984    | 0.34984    | 0.34984    |   0.0 |  0.29
Other   |            | 0.05869    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134166.0 ave      134166 max      134166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134166
Ave neighs/atom = 67.083000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.963311236816, Press = -0.757981620728263
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  198000   -13447.947   -13447.947   -13533.402   -13533.402    330.72099    330.72099    31343.459    31343.459   -853.92617   -853.92617 
  199000   -13444.602   -13444.602   -13531.745   -13531.745    337.25551    337.25551    31323.098    31323.098    957.78955    957.78955 
Loop time of 118.84 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.011 hours/ns, 8.415 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.34     | 118.34     | 118.34     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092824   | 0.092824   | 0.092824   |   0.0 |  0.08
Output  | 0.00015058 | 0.00015058 | 0.00015058 |   0.0 |  0.00
Modify  | 0.34888    | 0.34888    | 0.34888    |   0.0 |  0.29
Other   |            | 0.05928    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134298.0 ave      134298 max      134298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134298
Ave neighs/atom = 67.149000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.978325688438, Press = -0.607587564060564
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  199000   -13444.602   -13444.602   -13531.745   -13531.745    337.25551    337.25551    31323.098    31323.098    957.78955    957.78955 
  200000   -13445.479   -13445.479   -13532.322   -13532.322    336.09042    336.09042    31321.414    31321.414    1094.0855    1094.0855 
Loop time of 119.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.076 hours/ns, 8.398 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.57     | 118.57     | 118.57     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093735   | 0.093735   | 0.093735   |   0.0 |  0.08
Output  | 0.00015402 | 0.00015402 | 0.00015402 |   0.0 |  0.00
Modify  | 0.34969    | 0.34969    | 0.34969    |   0.0 |  0.29
Other   |            | 0.05945    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134782.0 ave      134782 max      134782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134782
Ave neighs/atom = 67.391000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.977787230221, Press = -0.412853177691841
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  200000   -13445.479   -13445.479   -13532.322   -13532.322    336.09042    336.09042    31321.414    31321.414    1094.0855    1094.0855 
  201000   -13450.199   -13450.199   -13535.407   -13535.407    329.76169    329.76169    31372.527    31372.527   -3582.2085   -3582.2085 
Loop time of 118.922 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.034 hours/ns, 8.409 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.42     | 118.42     | 118.42     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093489   | 0.093489   | 0.093489   |   0.0 |  0.08
Output  | 0.00015319 | 0.00015319 | 0.00015319 |   0.0 |  0.00
Modify  | 0.34881    | 0.34881    | 0.34881    |   0.0 |  0.29
Other   |            | 0.05881    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      134908.0 ave      134908 max      134908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134908
Ave neighs/atom = 67.454000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
31334.7020370866

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0