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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 5.427092581987381*${_u_distance}
variable latticeconst_converted equal 5.427092581987381*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.42709258198738
Lattice spacing in x,y,z = 5.4270926 5.4270926 5.4270926
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (54.270926 54.270926 54.270926)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (54.270926 54.270926 54.270926)
  create_atoms CPU = 0.009 seconds

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

kim_interactions Si

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

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


mass          1 ${mass_converted}
mass          1 28.0855

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 159845.969888008 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_477506997611_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
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.689 | 4.689 | 4.689 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -36695.539   -36695.539       -37040       -37040       333.15       333.15    159845.97    159845.97    2301.7287    2301.7287 
    1000   -36320.484   -36320.484   -36679.808   -36679.808    347.52554    347.52554    160698.15    160698.15   -464.16869   -464.16869 
Loop time of 122.328 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.706 ns/day, 33.980 hours/ns, 8.175 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    | 120.63     | 120.63     | 120.63     |   0.0 | 98.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20954    | 0.20954    | 0.20954    |   0.0 |  0.17
Output  | 0.00026378 | 0.00026378 | 0.00026378 |   0.0 |  0.00
Modify  | 1.3213     | 1.3213     | 1.3213     |   0.0 |  1.08
Other   |            | 0.1629     |            |       |  0.13

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

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

Performance: 0.730 ns/day, 32.854 hours/ns, 8.455 timesteps/s
100.0% 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.62     | 116.62     | 116.62     |   0.0 | 98.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20444    | 0.20444    | 0.20444    |   0.0 |  0.17
Output  | 0.00031118 | 0.00031118 | 0.00031118 |   0.0 |  0.00
Modify  | 1.2923     | 1.2923     | 1.2923     |   0.0 |  1.09
Other   |            | 0.1619     |            |       |  0.14

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

Total # of neighbors = 350478
Ave neighs/atom = 43.809750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -36357.451   -36357.451   -36689.332   -36689.332     320.9827     320.9827    160588.78    160588.78    32.771097    32.771097 
    3000   -36338.686   -36338.686   -36693.582   -36693.582    343.24217    343.24217    160507.43    160507.43    613.77263    613.77263 
Loop time of 117.661 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.684 hours/ns, 8.499 timesteps/s
100.0% 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.02     | 116.02     | 116.02     |   0.0 | 98.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20339    | 0.20339    | 0.20339    |   0.0 |  0.17
Output  | 0.00026497 | 0.00026497 | 0.00026497 |   0.0 |  0.00
Modify  | 1.2788     | 1.2788     | 1.2788     |   0.0 |  1.09
Other   |            | 0.1606     |            |       |  0.14

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

Total # of neighbors = 350852
Ave neighs/atom = 43.856500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -36338.686   -36338.686   -36693.582   -36693.582    343.24217    343.24217    160507.43    160507.43    613.77263    613.77263 
    4000   -36348.139   -36348.139   -36692.422   -36692.422    332.97785    332.97785    160716.19    160716.19   -659.91237   -659.91237 
Loop time of 118.723 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.728 ns/day, 32.979 hours/ns, 8.423 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.05     | 117.05     | 117.05     |   0.0 | 98.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21516    | 0.21516    | 0.21516    |   0.0 |  0.18
Output  | 0.00031723 | 0.00031723 | 0.00031723 |   0.0 |  0.00
Modify  | 1.2955     | 1.2955     | 1.2955     |   0.0 |  1.09
Other   |            | 0.1615     |            |       |  0.14

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

Total # of neighbors = 351482
Ave neighs/atom = 43.935250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -36348.139   -36348.139   -36692.422   -36692.422    332.97785    332.97785    160716.19    160716.19   -659.91237   -659.91237 
    5000   -36346.762   -36346.762   -36688.511   -36688.511    330.52686    330.52686    160511.39    160511.39    500.18506    500.18506 
Loop time of 118.622 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.728 ns/day, 32.951 hours/ns, 8.430 timesteps/s
100.0% 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 | 98.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21364    | 0.21364    | 0.21364    |   0.0 |  0.18
Output  | 0.00022822 | 0.00022822 | 0.00022822 |   0.0 |  0.00
Modify  | 1.3016     | 1.3016     | 1.3016     |   0.0 |  1.10
Other   |            | 0.1607     |            |       |  0.14

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

Total # of neighbors = 350714
Ave neighs/atom = 43.839250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.376449578935, Press = 726.692849329451
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -36346.762   -36346.762   -36688.511   -36688.511    330.52686    330.52686    160511.39    160511.39    500.18506    500.18506 
    6000   -36341.974   -36341.974   -36680.962   -36680.962    327.85664    327.85664    160532.42    160532.42    261.64411    261.64411 
Loop time of 118.867 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.16     | 117.16     | 117.16     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21324    | 0.21324    | 0.21324    |   0.0 |  0.18
Output  | 0.00023007 | 0.00023007 | 0.00023007 |   0.0 |  0.00
Modify  | 1.332      | 1.332      | 1.332      |   0.0 |  1.12
Other   |            | 0.1616     |            |       |  0.14

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

Total # of neighbors = 351376
Ave neighs/atom = 43.922000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.70333205709, Press = 14.0520102697868
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -36341.974   -36341.974   -36680.962   -36680.962    327.85664    327.85664    160532.42    160532.42    261.64411    261.64411 
    7000    -36349.93    -36349.93   -36686.622   -36686.622    325.63523    325.63523    160648.69    160648.69   -423.28688   -423.28688 
Loop time of 132.998 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.650 ns/day, 36.944 hours/ns, 7.519 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.03     | 131.03     | 131.03     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22378    | 0.22378    | 0.22378    |   0.0 |  0.17
Output  | 0.00027058 | 0.00027058 | 0.00027058 |   0.0 |  0.00
Modify  | 1.5689     | 1.5689     | 1.5689     |   0.0 |  1.18
Other   |            | 0.1762     |            |       |  0.13

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

Total # of neighbors = 350494
Ave neighs/atom = 43.811750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.117155304763, Press = 18.3346439560454
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -36349.93    -36349.93   -36686.622   -36686.622    325.63523    325.63523    160648.69    160648.69   -423.28688   -423.28688 
    8000   -36338.914   -36338.914   -36686.872   -36686.872    336.53182    336.53182    160533.97    160533.97    394.18751    394.18751 
Loop time of 126.573 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.683 ns/day, 35.159 hours/ns, 7.901 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    | 124.73     | 124.73     | 124.73     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21716    | 0.21716    | 0.21716    |   0.0 |  0.17
Output  | 0.00022992 | 0.00022992 | 0.00022992 |   0.0 |  0.00
Modify  | 1.4564     | 1.4564     | 1.4564     |   0.0 |  1.15
Other   |            | 0.1691     |            |       |  0.13

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

Total # of neighbors = 350446
Ave neighs/atom = 43.805750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.070943864308, Press = 11.8236082385359
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -36338.914   -36338.914   -36686.872   -36686.872    336.53182    336.53182    160533.97    160533.97    394.18751    394.18751 
    9000   -36350.058   -36350.058   -36689.209   -36689.209    328.01429    328.01429    160633.56    160633.56   -237.13764   -237.13764 
Loop time of 117.851 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.736 hours/ns, 8.485 timesteps/s
100.0% 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.17     | 116.17     | 116.17     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20635    | 0.20635    | 0.20635    |   0.0 |  0.18
Output  | 0.00022591 | 0.00022591 | 0.00022591 |   0.0 |  0.00
Modify  | 1.3136     | 1.3136     | 1.3136     |   0.0 |  1.11
Other   |            | 0.1597     |            |       |  0.14

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

Total # of neighbors = 351180
Ave neighs/atom = 43.897500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.035697781605, Press = 3.35262399111021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -36350.058   -36350.058   -36689.209   -36689.209    328.01429    328.01429    160633.56    160633.56   -237.13764   -237.13764 
   10000   -36341.698   -36341.698    -36690.28    -36690.28    337.13588    337.13588    160656.71    160656.71   -238.75356   -238.75356 
Loop time of 117.847 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.735 hours/ns, 8.486 timesteps/s
100.0% 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.16     | 116.16     | 116.16     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20726    | 0.20726    | 0.20726    |   0.0 |  0.18
Output  | 0.0003012  | 0.0003012  | 0.0003012  |   0.0 |  0.00
Modify  | 1.3138     | 1.3138     | 1.3138     |   0.0 |  1.11
Other   |            | 0.1611     |            |       |  0.14

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

Total # of neighbors = 350560
Ave neighs/atom = 43.820000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.156312499641, Press = 12.7018295874942
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -36341.698   -36341.698    -36690.28    -36690.28    337.13588    337.13588    160656.71    160656.71   -238.75356   -238.75356 
   11000   -36344.822   -36344.822   -36688.341   -36688.341    332.23867    332.23867    160428.52    160428.52    1005.3834    1005.3834 
Loop time of 117.819 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.728 hours/ns, 8.488 timesteps/s
100.0% 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.14     | 116.14     | 116.14     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20925    | 0.20925    | 0.20925    |   0.0 |  0.18
Output  | 0.00022237 | 0.00022237 | 0.00022237 |   0.0 |  0.00
Modify  | 1.3134     | 1.3134     | 1.3134     |   0.0 |  1.11
Other   |            | 0.1594     |            |       |  0.14

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

Total # of neighbors = 350948
Ave neighs/atom = 43.868500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.205027743881, Press = 3.3528517855564
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -36344.822   -36344.822   -36688.341   -36688.341    332.23867    332.23867    160428.52    160428.52    1005.3834    1005.3834 
   12000   -36339.417   -36339.417   -36697.465   -36697.465    346.29055    346.29055    160707.33    160707.33   -525.06049   -525.06049 
Loop time of 130.364 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.663 ns/day, 36.212 hours/ns, 7.671 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    | 128.44     | 128.44     | 128.44     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22367    | 0.22367    | 0.22367    |   0.0 |  0.17
Output  | 0.00028102 | 0.00028102 | 0.00028102 |   0.0 |  0.00
Modify  | 1.5262     | 1.5262     | 1.5262     |   0.0 |  1.17
Other   |            | 0.1768     |            |       |  0.14

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

Total # of neighbors = 351658
Ave neighs/atom = 43.957250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.469394760584, Press = 3.2662166868166
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -36339.417   -36339.417   -36697.465   -36697.465    346.29055    346.29055    160707.33    160707.33   -525.06049   -525.06049 
   13000   -36344.812   -36344.812   -36694.283   -36694.283     337.9952     337.9952    160555.47    160555.47    308.26562    308.26562 
Loop time of 119.018 on 1 procs for 1000 steps with 8000 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    | 117.29     | 117.29     | 117.29     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21693    | 0.21693    | 0.21693    |   0.0 |  0.18
Output  | 0.0002292  | 0.0002292  | 0.0002292  |   0.0 |  0.00
Modify  | 1.3441     | 1.3441     | 1.3441     |   0.0 |  1.13
Other   |            | 0.1635     |            |       |  0.14

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

Total # of neighbors = 350934
Ave neighs/atom = 43.866750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.446846220657, Press = 6.45397751789542
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -36344.812   -36344.812   -36694.283   -36694.283     337.9952     337.9952    160555.47    160555.47    308.26562    308.26562 
   14000   -36351.599   -36351.599   -36694.278   -36694.278    331.42677    331.42677    160540.47    160540.47    369.10329    369.10329 
Loop time of 118.908 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.18     | 117.18     | 117.18     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.218      | 0.218      | 0.218      |   0.0 |  0.18
Output  | 0.00023886 | 0.00023886 | 0.00023886 |   0.0 |  0.00
Modify  | 1.3441     | 1.3441     | 1.3441     |   0.0 |  1.13
Other   |            | 0.1641     |            |       |  0.14

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

Total # of neighbors = 351126
Ave neighs/atom = 43.890750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.47473269157, Press = 2.27620774210021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -36351.599   -36351.599   -36694.278   -36694.278    331.42677    331.42677    160540.47    160540.47    369.10329    369.10329 
   15000   -36340.693   -36340.693   -36690.864   -36690.864    338.67262    338.67262    160635.93    160635.93   -184.34933   -184.34933 
Loop time of 118.895 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.18     | 117.18     | 117.18     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21661    | 0.21661    | 0.21661    |   0.0 |  0.18
Output  | 0.00027912 | 0.00027912 | 0.00027912 |   0.0 |  0.00
Modify  | 1.3403     | 1.3403     | 1.3403     |   0.0 |  1.13
Other   |            | 0.1627     |            |       |  0.14

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

Total # of neighbors = 351142
Ave neighs/atom = 43.892750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.458227014369, Press = 3.24697848704127
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -36340.693   -36340.693   -36690.864   -36690.864    338.67262    338.67262    160635.93    160635.93   -184.34933   -184.34933 
   16000   -36348.814   -36348.814   -36688.476   -36688.476    328.50765    328.50765    160589.67    160589.67    8.2998425    8.2998425 
Loop time of 118.999 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.28     | 117.28     | 117.28     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21475    | 0.21475    | 0.21475    |   0.0 |  0.18
Output  | 0.00023063 | 0.00023063 | 0.00023063 |   0.0 |  0.00
Modify  | 1.3361     | 1.3361     | 1.3361     |   0.0 |  1.12
Other   |            | 0.1627     |            |       |  0.14

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

Total # of neighbors = 350906
Ave neighs/atom = 43.863250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.52924871704, Press = 3.07603041393011
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -36348.814   -36348.814   -36688.476   -36688.476    328.50765    328.50765    160589.67    160589.67    8.2998425    8.2998425 
   17000   -36343.923   -36343.923   -36689.289   -36689.289    334.02505    334.02505    160613.95    160613.95   -94.312313   -94.312313 
Loop time of 117.937 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.760 hours/ns, 8.479 timesteps/s
100.0% 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.25     | 116.25     | 116.25     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20846    | 0.20846    | 0.20846    |   0.0 |  0.18
Output  | 0.00026967 | 0.00026967 | 0.00026967 |   0.0 |  0.00
Modify  | 1.3179     | 1.3179     | 1.3179     |   0.0 |  1.12
Other   |            | 0.1615     |            |       |  0.14

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

Total # of neighbors = 350890
Ave neighs/atom = 43.861250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.533681586509, Press = 2.2070548167929
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -36343.923   -36343.923   -36689.289   -36689.289    334.02505    334.02505    160613.95    160613.95   -94.312313   -94.312313 
   18000   -36343.998   -36343.998   -36690.304   -36690.304     334.9342     334.9342     160657.3     160657.3   -398.21424   -398.21424 
Loop time of 117.779 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.716 hours/ns, 8.490 timesteps/s
100.0% 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.1      | 116.1      | 116.1      |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20668    | 0.20668    | 0.20668    |   0.0 |  0.18
Output  | 0.00022768 | 0.00022768 | 0.00022768 |   0.0 |  0.00
Modify  | 1.3124     | 1.3124     | 1.3124     |   0.0 |  1.11
Other   |            | 0.1617     |            |       |  0.14

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

Total # of neighbors = 351092
Ave neighs/atom = 43.886500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.509541992125, Press = 2.78540060383458
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -36343.998   -36343.998   -36690.304   -36690.304     334.9342     334.9342     160657.3     160657.3   -398.21424   -398.21424 
   19000   -36346.643   -36346.643   -36689.019   -36689.019     331.1337     331.1337    160416.35    160416.35    1091.4462    1091.4462 
Loop time of 139.05 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.621 ns/day, 38.625 hours/ns, 7.192 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    | 136.97     | 136.97     | 136.97     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22756    | 0.22756    | 0.22756    |   0.0 |  0.16
Output  | 0.00022924 | 0.00022924 | 0.00022924 |   0.0 |  0.00
Modify  | 1.6659     | 1.6659     | 1.6659     |   0.0 |  1.20
Other   |            | 0.1848     |            |       |  0.13

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

Total # of neighbors = 350596
Ave neighs/atom = 43.824500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4592402311, Press = 2.80382623357158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -36346.643   -36346.643   -36689.019   -36689.019     331.1337     331.1337    160416.35    160416.35    1091.4462    1091.4462 
   20000   -36348.935   -36348.935    -36693.88    -36693.88    333.61773    333.61773    160653.97    160653.97   -327.32323   -327.32323 
Loop time of 131.995 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.655 ns/day, 36.665 hours/ns, 7.576 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    | 130.04     | 130.04     | 130.04     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22229    | 0.22229    | 0.22229    |   0.0 |  0.17
Output  | 0.00022729 | 0.00022729 | 0.00022729 |   0.0 |  0.00
Modify  | 1.5514     | 1.5514     | 1.5514     |   0.0 |  1.18
Other   |            | 0.1775     |            |       |  0.13

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

Total # of neighbors = 351634
Ave neighs/atom = 43.954250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.442290290077, Press = 0.85018550534119
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -36348.935   -36348.935    -36693.88    -36693.88    333.61773    333.61773    160653.97    160653.97   -327.32323   -327.32323 
   21000   -36344.219   -36344.219   -36689.176   -36689.176    333.62977    333.62977    160604.09    160604.09   -57.753857   -57.753857 
Loop time of 117.69 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.692 hours/ns, 8.497 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116        | 116        | 116        |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20781    | 0.20781    | 0.20781    |   0.0 |  0.18
Output  | 0.00023879 | 0.00023879 | 0.00023879 |   0.0 |  0.00
Modify  | 1.3177     | 1.3177     | 1.3177     |   0.0 |  1.12
Other   |            | 0.1606     |            |       |  0.14

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

Total # of neighbors = 350548
Ave neighs/atom = 43.818500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.471851161007, Press = 2.87558227770062
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -36344.219   -36344.219   -36689.176   -36689.176    333.62977    333.62977    160604.09    160604.09   -57.753857   -57.753857 
   22000    -36350.52    -36350.52   -36692.763   -36692.763    331.00495    331.00495    160502.53    160502.53    517.31054    517.31054 
Loop time of 117.773 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.715 hours/ns, 8.491 timesteps/s
100.0% 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.08     | 116.08     | 116.08     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20967    | 0.20967    | 0.20967    |   0.0 |  0.18
Output  | 0.00024231 | 0.00024231 | 0.00024231 |   0.0 |  0.00
Modify  | 1.3181     | 1.3181     | 1.3181     |   0.0 |  1.12
Other   |            | 0.1616     |            |       |  0.14

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

Total # of neighbors = 350574
Ave neighs/atom = 43.821750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.424990499779, Press = 1.06712263490553
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -36350.52    -36350.52   -36692.763   -36692.763    331.00495    331.00495    160502.53    160502.53    517.31054    517.31054 
   23000   -36341.559   -36341.559   -36693.634   -36693.634    340.51367    340.51367    160738.54    160738.54   -805.34591   -805.34591 
Loop time of 117.926 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.757 hours/ns, 8.480 timesteps/s
100.0% 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.23     | 116.23     | 116.23     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21075    | 0.21075    | 0.21075    |   0.0 |  0.18
Output  | 0.00022694 | 0.00022694 | 0.00022694 |   0.0 |  0.00
Modify  | 1.3206     | 1.3206     | 1.3206     |   0.0 |  1.12
Other   |            | 0.1609     |            |       |  0.14

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

Total # of neighbors = 351496
Ave neighs/atom = 43.937000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.405203771508, Press = 1.25873306107907
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -36341.559   -36341.559   -36693.634   -36693.634    340.51367    340.51367    160738.54    160738.54   -805.34591   -805.34591 
   24000   -36346.144   -36346.144   -36687.383   -36687.383    330.03378    330.03378     160529.1     160529.1    392.32946    392.32946 
Loop time of 117.752 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.709 hours/ns, 8.492 timesteps/s
100.0% 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.06     | 116.06     | 116.06     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20844    | 0.20844    | 0.20844    |   0.0 |  0.18
Output  | 0.00023671 | 0.00023671 | 0.00023671 |   0.0 |  0.00
Modify  | 1.319      | 1.319      | 1.319      |   0.0 |  1.12
Other   |            | 0.1611     |            |       |  0.14

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

Total # of neighbors = 350594
Ave neighs/atom = 43.824250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.405663282285, Press = 2.88246704066893
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -36346.144   -36346.144   -36687.383   -36687.383    330.03378    330.03378     160529.1     160529.1    392.32946    392.32946 
   25000   -36345.788   -36345.788   -36690.515   -36690.515    333.40718    333.40718     160528.1     160528.1    365.38781    365.38781 
Loop time of 124.121 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.696 ns/day, 34.478 hours/ns, 8.057 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    | 122.32     | 122.32     | 122.32     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2166     | 0.2166     | 0.2166     |   0.0 |  0.17
Output  | 0.00027655 | 0.00027655 | 0.00027655 |   0.0 |  0.00
Modify  | 1.4099     | 1.4099     | 1.4099     |   0.0 |  1.14
Other   |            | 0.169      |            |       |  0.14

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

Total # of neighbors = 351348
Ave neighs/atom = 43.918500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.472463519917, Press = 0.113936980110549
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -36345.788   -36345.788   -36690.515   -36690.515    333.40718    333.40718     160528.1     160528.1    365.38781    365.38781 
   26000   -36339.865   -36339.865   -36689.293   -36689.293    337.95342    337.95342    160706.11    160706.11   -562.32374   -562.32374 
Loop time of 139.171 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.621 ns/day, 38.659 hours/ns, 7.185 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.1      | 137.1      | 137.1      |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23559    | 0.23559    | 0.23559    |   0.0 |  0.17
Output  | 0.00029032 | 0.00029032 | 0.00029032 |   0.0 |  0.00
Modify  | 1.6492     | 1.6492     | 1.6492     |   0.0 |  1.19
Other   |            | 0.187      |            |       |  0.13

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

Total # of neighbors = 351418
Ave neighs/atom = 43.927250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.50148620159, Press = 1.99781729830485
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -36339.865   -36339.865   -36689.293   -36689.293    337.95342    337.95342    160706.11    160706.11   -562.32374   -562.32374 
   27000   -36345.617   -36345.617    -36690.88    -36690.88    333.92593    333.92593    160525.62    160525.62    423.09626    423.09626 
Loop time of 118.168 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.731 ns/day, 32.824 hours/ns, 8.463 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    | 116.48     | 116.48     | 116.48     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2073     | 0.2073     | 0.2073     |   0.0 |  0.18
Output  | 0.00022437 | 0.00022437 | 0.00022437 |   0.0 |  0.00
Modify  | 1.3207     | 1.3207     | 1.3207     |   0.0 |  1.12
Other   |            | 0.1627     |            |       |  0.14

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

Total # of neighbors = 350694
Ave neighs/atom = 43.836750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.553168291762, Press = 1.76504163758641
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -36345.617   -36345.617    -36690.88    -36690.88    333.92593    333.92593    160525.62    160525.62    423.09626    423.09626 
   28000   -36337.637   -36337.637   -36686.969   -36686.969    337.86054    337.86054    160615.69    160615.69   -40.269215   -40.269215 
Loop time of 129.774 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.666 ns/day, 36.048 hours/ns, 7.706 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    | 127.87     | 127.87     | 127.87     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21889    | 0.21889    | 0.21889    |   0.0 |  0.17
Output  | 0.00022637 | 0.00022637 | 0.00022637 |   0.0 |  0.00
Modify  | 1.515      | 1.515      | 1.515      |   0.0 |  1.17
Other   |            | 0.174      |            |       |  0.13

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

Total # of neighbors = 351290
Ave neighs/atom = 43.911250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.548459061187, Press = 0.832008811447437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -36337.637   -36337.637   -36686.969   -36686.969    337.86054    337.86054    160615.69    160615.69   -40.269215   -40.269215 
   29000   -36342.725   -36342.725   -36683.862   -36683.862    329.93542    329.93542    160688.34    160688.34   -474.62969   -474.62969 
Loop time of 135.043 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.640 ns/day, 37.512 hours/ns, 7.405 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    | 133.03     | 133.03     | 133.03     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23234    | 0.23234    | 0.23234    |   0.0 |  0.17
Output  | 0.00028496 | 0.00028496 | 0.00028496 |   0.0 |  0.00
Modify  | 1.5966     | 1.5966     | 1.5966     |   0.0 |  1.18
Other   |            | 0.1816     |            |       |  0.13

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

Total # of neighbors = 350620
Ave neighs/atom = 43.827500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.629999154954, Press = 1.86489091550367
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -36342.725   -36342.725   -36683.862   -36683.862    329.93542    329.93542    160688.34    160688.34   -474.62969   -474.62969 
   30000   -36348.533   -36348.533   -36690.274   -36690.274    330.51928    330.51928    160362.04    160362.04    1404.8216    1404.8216 
Loop time of 129.315 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.668 ns/day, 35.921 hours/ns, 7.733 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.41     | 127.41     | 127.41     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21941    | 0.21941    | 0.21941    |   0.0 |  0.17
Output  | 0.00053801 | 0.00053801 | 0.00053801 |   0.0 |  0.00
Modify  | 1.5157     | 1.5157     | 1.5157     |   0.0 |  1.17
Other   |            | 0.1735     |            |       |  0.13

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

Total # of neighbors = 350498
Ave neighs/atom = 43.812250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.596923626996, Press = 1.97252196163493
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -36348.533   -36348.533   -36690.274   -36690.274    330.51928    330.51928    160362.04    160362.04    1404.8216    1404.8216 
   31000   -36343.567   -36343.567   -36687.954   -36687.954    333.07856    333.07856    160699.76    160699.76   -608.24342   -608.24342 
Loop time of 122.573 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.705 ns/day, 34.048 hours/ns, 8.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    | 120.79     | 120.79     | 120.79     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21214    | 0.21214    | 0.21214    |   0.0 |  0.17
Output  | 0.00022367 | 0.00022367 | 0.00022367 |   0.0 |  0.00
Modify  | 1.3977     | 1.3977     | 1.3977     |   0.0 |  1.14
Other   |            | 0.1678     |            |       |  0.14

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

Total # of neighbors = 351866
Ave neighs/atom = 43.983250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.593850487551, Press = -0.0294393148857174
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -36343.567   -36343.567   -36687.954   -36687.954    333.07856    333.07856    160699.76    160699.76   -608.24342   -608.24342 
   32000   -36346.591   -36346.591   -36694.184   -36694.184    336.17958    336.17958    160637.41    160637.41   -175.10795   -175.10795 
Loop time of 133.124 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.649 ns/day, 36.979 hours/ns, 7.512 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.14     | 131.14     | 131.14     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22226    | 0.22226    | 0.22226    |   0.0 |  0.17
Output  | 0.0002858  | 0.0002858  | 0.0002858  |   0.0 |  0.00
Modify  | 1.5847     | 1.5847     | 1.5847     |   0.0 |  1.19
Other   |            | 0.1781     |            |       |  0.13

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

Total # of neighbors = 350442
Ave neighs/atom = 43.805250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.576988034829, Press = 2.1475854053062
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -36346.591   -36346.591   -36694.184   -36694.184    336.17958    336.17958    160637.41    160637.41   -175.10795   -175.10795 
   33000   -36341.516   -36341.516   -36688.063   -36688.063    335.16724    335.16724    160532.65    160532.65     502.8142     502.8142 
Loop time of 139.503 on 1 procs for 1000 steps with 8000 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    | 137.42     | 137.42     | 137.42     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23017    | 0.23017    | 0.23017    |   0.0 |  0.16
Output  | 0.0002826  | 0.0002826  | 0.0002826  |   0.0 |  0.00
Modify  | 1.6728     | 1.6728     | 1.6728     |   0.0 |  1.20
Other   |            | 0.1831     |            |       |  0.13

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

Total # of neighbors = 350922
Ave neighs/atom = 43.865250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.57162220804, Press = 1.23709576567361
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -36341.516   -36341.516   -36688.063   -36688.063    335.16724    335.16724    160532.65    160532.65     502.8142     502.8142 
   34000   -36343.907   -36343.907   -36689.154   -36689.154    333.91019    333.91019    160646.76    160646.76   -295.94536   -295.94536 
Loop time of 118.869 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.727 ns/day, 33.019 hours/ns, 8.413 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    | 117.16     | 117.16     | 117.16     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20906    | 0.20906    | 0.20906    |   0.0 |  0.18
Output  | 0.00027842 | 0.00027842 | 0.00027842 |   0.0 |  0.00
Modify  | 1.336      | 1.336      | 1.336      |   0.0 |  1.12
Other   |            | 0.1633     |            |       |  0.14

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

Total # of neighbors = 351204
Ave neighs/atom = 43.900500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.559771977619, Press = 0.931991074611993
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -36343.907   -36343.907   -36689.154   -36689.154    333.91019    333.91019    160646.76    160646.76   -295.94536   -295.94536 
   35000   -36342.553   -36342.553   -36686.717   -36686.717    332.86248    332.86248    160603.16    160603.16    8.8770955    8.8770955 
Loop time of 117.356 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.67     | 115.67     | 115.67     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20749    | 0.20749    | 0.20749    |   0.0 |  0.18
Output  | 0.00028108 | 0.00028108 | 0.00028108 |   0.0 |  0.00
Modify  | 1.3133     | 1.3133     | 1.3133     |   0.0 |  1.12
Other   |            | 0.1606     |            |       |  0.14

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

Total # of neighbors = 350844
Ave neighs/atom = 43.855500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.601727337288, Press = 1.62993681164371
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -36342.553   -36342.553   -36686.717   -36686.717    332.86248    332.86248    160603.16    160603.16    8.8770955    8.8770955 
   36000   -36348.339   -36348.339   -36687.318   -36687.318    327.84751    327.84751     160481.4     160481.4    648.47196    648.47196 
Loop time of 117.268 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.574 hours/ns, 8.528 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.59     | 115.59     | 115.59     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20594    | 0.20594    | 0.20594    |   0.0 |  0.18
Output  | 0.00023618 | 0.00023618 | 0.00023618 |   0.0 |  0.00
Modify  | 1.3128     | 1.3128     | 1.3128     |   0.0 |  1.12
Other   |            | 0.1612     |            |       |  0.14

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

Total # of neighbors = 350756
Ave neighs/atom = 43.844500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.569935101145, Press = 0.463760858464226
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -36348.339   -36348.339   -36687.318   -36687.318    327.84751    327.84751     160481.4     160481.4    648.47196    648.47196 
   37000   -36343.027   -36343.027   -36686.769   -36686.769    332.45538    332.45538    160831.46    160831.46   -1461.3574   -1461.3574 
Loop time of 117.29 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.580 hours/ns, 8.526 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.61     | 115.61     | 115.61     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20713    | 0.20713    | 0.20713    |   0.0 |  0.18
Output  | 0.00028155 | 0.00028155 | 0.00028155 |   0.0 |  0.00
Modify  | 1.3113     | 1.3113     | 1.3113     |   0.0 |  1.12
Other   |            | 0.1618     |            |       |  0.14

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

Total # of neighbors = 351066
Ave neighs/atom = 43.883250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.578094784888, Press = 0.978881982528346
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -36343.027   -36343.027   -36686.769   -36686.769    332.45538    332.45538    160831.46    160831.46   -1461.3574   -1461.3574 
   38000   -36340.791   -36340.791   -36688.693   -36688.693    336.47809    336.47809    160557.91    160557.91    304.35061    304.35061 
Loop time of 135.557 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.637 ns/day, 37.655 hours/ns, 7.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    | 133.53     | 133.53     | 133.53     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22663    | 0.22663    | 0.22663    |   0.0 |  0.17
Output  | 0.00028783 | 0.00028783 | 0.00028783 |   0.0 |  0.00
Modify  | 1.6245     | 1.6245     | 1.6245     |   0.0 |  1.20
Other   |            | 0.1802     |            |       |  0.13

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

Total # of neighbors = 349896
Ave neighs/atom = 43.737000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.553645855639, Press = 1.63306858865123
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -36340.791   -36340.791   -36688.693   -36688.693    336.47809    336.47809    160557.91    160557.91    304.35061    304.35061 
   39000    -36354.14    -36354.14   -36696.248   -36696.248    330.87402    330.87402    160590.14    160590.14   -1.5876126   -1.5876126 
Loop time of 138.974 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.604 hours/ns, 7.196 timesteps/s
100.0% 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.89     | 136.89     | 136.89     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23048    | 0.23048    | 0.23048    |   0.0 |  0.17
Output  | 0.00026751 | 0.00026751 | 0.00026751 |   0.0 |  0.00
Modify  | 1.6746     | 1.6746     | 1.6746     |   0.0 |  1.20
Other   |            | 0.1835     |            |       |  0.13

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

Total # of neighbors = 350926
Ave neighs/atom = 43.865750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.52545026218, Press = 0.691970443345907
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -36354.14    -36354.14   -36696.248   -36696.248    330.87402    330.87402    160590.14    160590.14   -1.5876126   -1.5876126 
   40000   -36340.951   -36340.951    -36688.75    -36688.75    336.37818    336.37818    160712.05    160712.05   -605.00603   -605.00603 
Loop time of 135.71 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.637 ns/day, 37.697 hours/ns, 7.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    | 133.68     | 133.68     | 133.68     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.227      | 0.227      | 0.227      |   0.0 |  0.17
Output  | 0.0002227  | 0.0002227  | 0.0002227  |   0.0 |  0.00
Modify  | 1.6247     | 1.6247     | 1.6247     |   0.0 |  1.20
Other   |            | 0.1794     |            |       |  0.13

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

Total # of neighbors = 351338
Ave neighs/atom = 43.917250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.475041767549, Press = 1.30039176628223
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -36340.951   -36340.951    -36688.75    -36688.75    336.37818    336.37818    160712.05    160712.05   -605.00603   -605.00603 
   41000   -36343.797   -36343.797   -36690.864   -36690.864    335.67032    335.67032    160430.15    160430.15    1074.7649    1074.7649 
Loop time of 117.577 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.660 hours/ns, 8.505 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.89     | 115.89     | 115.89     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20864    | 0.20864    | 0.20864    |   0.0 |  0.18
Output  | 0.00022555 | 0.00022555 | 0.00022555 |   0.0 |  0.00
Modify  | 1.3147     | 1.3147     | 1.3147     |   0.0 |  1.12
Other   |            | 0.1616     |            |       |  0.14

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

Total # of neighbors = 350626
Ave neighs/atom = 43.828250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.468155980957, Press = 1.14503883613831
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -36343.797   -36343.797   -36690.864   -36690.864    335.67032    335.67032    160430.15    160430.15    1074.7649    1074.7649 
   42000   -36341.421   -36341.421   -36691.573   -36691.573    338.65424    338.65424    160703.51    160703.51     -644.536     -644.536 
Loop time of 137.617 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.628 ns/day, 38.227 hours/ns, 7.267 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    | 135.57     | 135.57     | 135.57     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23154    | 0.23154    | 0.23154    |   0.0 |  0.17
Output  | 0.00023139 | 0.00023139 | 0.00023139 |   0.0 |  0.00
Modify  | 1.6361     | 1.6361     | 1.6361     |   0.0 |  1.19
Other   |            | 0.1835     |            |       |  0.13

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

Total # of neighbors = 351484
Ave neighs/atom = 43.935500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.507595009429, Press = 0.307337106814083
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -36341.421   -36341.421   -36691.573   -36691.573    338.65424    338.65424    160703.51    160703.51     -644.536     -644.536 
   43000   -36346.035   -36346.035   -36691.101   -36691.101    333.73462    333.73462    160624.73    160624.73   -150.64052   -150.64052 
Loop time of 117.913 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.754 hours/ns, 8.481 timesteps/s
100.0% 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.22     | 116.22     | 116.22     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20609    | 0.20609    | 0.20609    |   0.0 |  0.17
Output  | 0.00022544 | 0.00022544 | 0.00022544 |   0.0 |  0.00
Modify  | 1.3212     | 1.3212     | 1.3212     |   0.0 |  1.12
Other   |            | 0.1621     |            |       |  0.14

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

Total # of neighbors = 350532
Ave neighs/atom = 43.816500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.510782767451, Press = 1.49601292854891
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -36346.035   -36346.035   -36691.101   -36691.101    333.73462    333.73462    160624.73    160624.73   -150.64052   -150.64052 
   44000   -36350.947   -36350.947   -36693.703   -36693.703    331.50018    331.50018    160530.13    160530.13    337.81757    337.81757 
Loop time of 117.353 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.67     | 115.67     | 115.67     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20607    | 0.20607    | 0.20607    |   0.0 |  0.18
Output  | 0.00022519 | 0.00022519 | 0.00022519 |   0.0 |  0.00
Modify  | 1.3108     | 1.3108     | 1.3108     |   0.0 |  1.12
Other   |            | 0.1616     |            |       |  0.14

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

Total # of neighbors = 350714
Ave neighs/atom = 43.839250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.513925912075, Press = 0.857670075857215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -36350.947   -36350.947   -36693.703   -36693.703    331.50018    331.50018    160530.13    160530.13    337.81757    337.81757 
   45000   -36347.428   -36347.428   -36689.471   -36689.471    330.81121    330.81121     160673.6     160673.6   -565.92941   -565.92941 
Loop time of 117.474 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.632 hours/ns, 8.513 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.8      | 115.8      | 115.8      |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20588    | 0.20588    | 0.20588    |   0.0 |  0.18
Output  | 0.00022594 | 0.00022594 | 0.00022594 |   0.0 |  0.00
Modify  | 1.3114     | 1.3114     | 1.3114     |   0.0 |  1.12
Other   |            | 0.1611     |            |       |  0.14

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

Total # of neighbors = 351476
Ave neighs/atom = 43.934500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.498886616421, Press = 0.816635347181491
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -36347.428   -36347.428   -36689.471   -36689.471    330.81121    330.81121     160673.6     160673.6   -565.92941   -565.92941 
   46000   -36347.743   -36347.743   -36693.992   -36693.992    334.87881    334.87881    160553.37    160553.37    214.19296    214.19296 
Loop time of 117.279 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.577 hours/ns, 8.527 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.6      | 115.6      | 115.6      |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20753    | 0.20753    | 0.20753    |   0.0 |  0.18
Output  | 0.00022466 | 0.00022466 | 0.00022466 |   0.0 |  0.00
Modify  | 1.31       | 1.31       | 1.31       |   0.0 |  1.12
Other   |            | 0.1612     |            |       |  0.14

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

Total # of neighbors = 350328
Ave neighs/atom = 43.791000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.461027408596, Press = 1.19966286561025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -36347.743   -36347.743   -36693.992   -36693.992    334.87881    334.87881    160553.37    160553.37    214.19296    214.19296 
   47000    -36345.98    -36345.98   -36688.922   -36688.922    331.68122    331.68122    160550.74    160550.74     333.2321     333.2321 
Loop time of 118.628 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.728 ns/day, 32.952 hours/ns, 8.430 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    | 116.93     | 116.93     | 116.93     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20994    | 0.20994    | 0.20994    |   0.0 |  0.18
Output  | 0.00022656 | 0.00022656 | 0.00022656 |   0.0 |  0.00
Modify  | 1.3284     | 1.3284     | 1.3284     |   0.0 |  1.12
Other   |            | 0.1623     |            |       |  0.14

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

Total # of neighbors = 351106
Ave neighs/atom = 43.888250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.458967421348, Press = 0.464836924744739
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -36345.98    -36345.98   -36688.922   -36688.922    331.68122    331.68122    160550.74    160550.74     333.2321     333.2321 
   48000   -36339.181   -36339.181   -36687.558   -36687.558    336.93656    336.93656    160802.05    160802.05   -1146.4993   -1146.4993 
Loop time of 118.644 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.728 ns/day, 32.957 hours/ns, 8.429 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    | 116.94     | 116.94     | 116.94     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21098    | 0.21098    | 0.21098    |   0.0 |  0.18
Output  | 0.00022657 | 0.00022657 | 0.00022657 |   0.0 |  0.00
Modify  | 1.3273     | 1.3273     | 1.3273     |   0.0 |  1.12
Other   |            | 0.1629     |            |       |  0.14

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

Total # of neighbors = 351180
Ave neighs/atom = 43.897500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.454219034786, Press = 1.06993322627013
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -36339.181   -36339.181   -36687.558   -36687.558    336.93656    336.93656    160802.05    160802.05   -1146.4993   -1146.4993 
   49000    -36344.42    -36344.42   -36695.768   -36695.768      339.811      339.811    160425.19    160425.19    1046.5385    1046.5385 
Loop time of 117.188 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.552 hours/ns, 8.533 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.51     | 115.51     | 115.51     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20282    | 0.20282    | 0.20282    |   0.0 |  0.17
Output  | 0.00028069 | 0.00028069 | 0.00028069 |   0.0 |  0.00
Modify  | 1.311      | 1.311      | 1.311      |   0.0 |  1.12
Other   |            | 0.1621     |            |       |  0.14

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

Total # of neighbors = 350132
Ave neighs/atom = 43.766500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.453919507152, Press = 1.1352917640692
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000    -36344.42    -36344.42   -36695.768   -36695.768      339.811      339.811    160425.19    160425.19    1046.5385    1046.5385 
   50000   -36340.033   -36340.033   -36685.625   -36685.625    334.24365    334.24365    160624.55    160624.55   -62.151988   -62.151988 
Loop time of 117.866 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.741 hours/ns, 8.484 timesteps/s
100.0% 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.18     | 116.18     | 116.18     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20573    | 0.20573    | 0.20573    |   0.0 |  0.17
Output  | 0.00022371 | 0.00022371 | 0.00022371 |   0.0 |  0.00
Modify  | 1.3212     | 1.3212     | 1.3212     |   0.0 |  1.12
Other   |            | 0.1619     |            |       |  0.14

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

Total # of neighbors = 351890
Ave neighs/atom = 43.986250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.48628212112, Press = 0.444461820922013
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -36340.033   -36340.033   -36685.625   -36685.625    334.24365    334.24365    160624.55    160624.55   -62.151988   -62.151988 
   51000   -36345.544   -36345.544    -36687.58    -36687.58    330.80443    330.80443    160625.98    160625.98   -105.11182   -105.11182 
Loop time of 117.636 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.677 hours/ns, 8.501 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.95     | 115.95     | 115.95     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20507    | 0.20507    | 0.20507    |   0.0 |  0.17
Output  | 0.00028872 | 0.00028872 | 0.00028872 |   0.0 |  0.00
Modify  | 1.3186     | 1.3186     | 1.3186     |   0.0 |  1.12
Other   |            | 0.1616     |            |       |  0.14

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

Total # of neighbors = 350568
Ave neighs/atom = 43.821000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.498130780481, Press = 1.01466958569609
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -36345.544   -36345.544    -36687.58    -36687.58    330.80443    330.80443    160625.98    160625.98   -105.11182   -105.11182 
   52000   -36342.632   -36342.632   -36690.824   -36690.824    336.75812    336.75812    160530.45    160530.45    463.10083    463.10083 
Loop time of 117.628 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.674 hours/ns, 8.501 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.94     | 115.94     | 115.94     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20553    | 0.20553    | 0.20553    |   0.0 |  0.17
Output  | 0.00022366 | 0.00022366 | 0.00022366 |   0.0 |  0.00
Modify  | 1.3185     | 1.3185     | 1.3185     |   0.0 |  1.12
Other   |            | 0.1614     |            |       |  0.14

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

Total # of neighbors = 350738
Ave neighs/atom = 43.842250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.517526859704, Press = 0.759388579537255
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -36342.632   -36342.632   -36690.824   -36690.824    336.75812    336.75812    160530.45    160530.45    463.10083    463.10083 
   53000   -36346.888   -36346.888     -36688.7     -36688.7    330.58818    330.58818    160657.61    160657.61   -257.13626   -257.13626 
Loop time of 117.868 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.741 hours/ns, 8.484 timesteps/s
100.0% 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.18     | 116.18     | 116.18     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20887    | 0.20887    | 0.20887    |   0.0 |  0.18
Output  | 0.00027559 | 0.00027559 | 0.00027559 |   0.0 |  0.00
Modify  | 1.3198     | 1.3198     | 1.3198     |   0.0 |  1.12
Other   |            | 0.1601     |            |       |  0.14

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

Total # of neighbors = 351042
Ave neighs/atom = 43.880250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.520243389301, Press = 0.369060319427154
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -36346.888   -36346.888     -36688.7     -36688.7    330.58818    330.58818    160657.61    160657.61   -257.13626   -257.13626 
   54000   -36345.027   -36345.027   -36692.716   -36692.716    336.27167    336.27167    160577.64    160577.64    158.53772    158.53772 
Loop time of 117.913 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.754 hours/ns, 8.481 timesteps/s
100.0% 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.22     | 116.22     | 116.22     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2075     | 0.2075     | 0.2075     |   0.0 |  0.18
Output  | 0.0002763  | 0.0002763  | 0.0002763  |   0.0 |  0.00
Modify  | 1.3209     | 1.3209     | 1.3209     |   0.0 |  1.12
Other   |            | 0.1607     |            |       |  0.14

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

Total # of neighbors = 350702
Ave neighs/atom = 43.837750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.516923879729, Press = 1.43731238551818
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -36345.027   -36345.027   -36692.716   -36692.716    336.27167    336.27167    160577.64    160577.64    158.53772    158.53772 
   55000   -36338.159   -36338.159   -36688.702   -36688.702     339.0319     339.0319    160504.62    160504.62    647.32704    647.32704 
Loop time of 138.895 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.582 hours/ns, 7.200 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 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22872    | 0.22872    | 0.22872    |   0.0 |  0.16
Output  | 0.00032815 | 0.00032815 | 0.00032815 |   0.0 |  0.00
Modify  | 1.6715     | 1.6715     | 1.6715     |   0.0 |  1.20
Other   |            | 0.1831     |            |       |  0.13

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

Total # of neighbors = 351012
Ave neighs/atom = 43.876500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.523042714892, Press = 0.38640971385709
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -36338.159   -36338.159   -36688.702   -36688.702     339.0319     339.0319    160504.62    160504.62    647.32704    647.32704 
   56000   -36344.893   -36344.893   -36690.443   -36690.443    334.20324    334.20324    160668.76    160668.76   -354.39622   -354.39622 
Loop time of 139.693 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.618 ns/day, 38.804 hours/ns, 7.159 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.6      | 137.6      | 137.6      |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23134    | 0.23134    | 0.23134    |   0.0 |  0.17
Output  | 0.00024932 | 0.00024932 | 0.00024932 |   0.0 |  0.00
Modify  | 1.6751     | 1.6751     | 1.6751     |   0.0 |  1.20
Other   |            | 0.1835     |            |       |  0.13

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

Total # of neighbors = 351266
Ave neighs/atom = 43.908250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.523207083088, Press = 0.649135567417029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -36344.893   -36344.893   -36690.443   -36690.443    334.20324    334.20324    160668.76    160668.76   -354.39622   -354.39622 
   57000   -36341.571   -36341.571   -36687.525   -36687.525    334.59371    334.59371    160541.97    160541.97    355.64549    355.64549 
Loop time of 138.323 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.625 ns/day, 38.423 hours/ns, 7.229 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.25     | 136.25     | 136.25     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23081    | 0.23081    | 0.23081    |   0.0 |  0.17
Output  | 0.00029243 | 0.00029243 | 0.00029243 |   0.0 |  0.00
Modify  | 1.6634     | 1.6634     | 1.6634     |   0.0 |  1.20
Other   |            | 0.1834     |            |       |  0.13

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

Total # of neighbors = 350598
Ave neighs/atom = 43.824750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.549603509251, Press = 0.878452905290755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -36341.571   -36341.571   -36687.525   -36687.525    334.59371    334.59371    160541.97    160541.97    355.64549    355.64549 
   58000   -36340.359   -36340.359    -36686.57    -36686.57    334.84315    334.84315    160598.34    160598.34    77.934316    77.934316 
Loop time of 128.03 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.675 ns/day, 35.564 hours/ns, 7.811 timesteps/s
100.0% 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.15     | 126.15     | 126.15     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21908    | 0.21908    | 0.21908    |   0.0 |  0.17
Output  | 0.00022706 | 0.00022706 | 0.00022706 |   0.0 |  0.00
Modify  | 1.4868     | 1.4868     | 1.4868     |   0.0 |  1.16
Other   |            | 0.1721     |            |       |  0.13

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

Total # of neighbors = 351300
Ave neighs/atom = 43.912500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.546275497615, Press = 0.387756844777821
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -36340.359   -36340.359    -36686.57    -36686.57    334.84315    334.84315    160598.34    160598.34    77.934316    77.934316 
   59000   -36345.534   -36345.534   -36690.906   -36690.906    334.03054    334.03054    160761.85    160761.85   -876.72884   -876.72884 
Loop time of 117.838 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.733 hours/ns, 8.486 timesteps/s
100.0% 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.15     | 116.15     | 116.15     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20993    | 0.20993    | 0.20993    |   0.0 |  0.18
Output  | 0.00027503 | 0.00027503 | 0.00027503 |   0.0 |  0.00
Modify  | 1.3177     | 1.3177     | 1.3177     |   0.0 |  1.12
Other   |            | 0.1615     |            |       |  0.14

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

Total # of neighbors = 350900
Ave neighs/atom = 43.862500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.518138883588, Press = 0.977395148082552
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -36345.534   -36345.534   -36690.906   -36690.906    334.03054    334.03054    160761.85    160761.85   -876.72884   -876.72884 
   60000   -36349.148   -36349.148    -36693.37    -36693.37    332.91875    332.91875    160403.28    160403.28    1133.6858    1133.6858 
Loop time of 117.744 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.707 hours/ns, 8.493 timesteps/s
100.0% 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.06     | 116.06     | 116.06     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20942    | 0.20942    | 0.20942    |   0.0 |  0.18
Output  | 0.0002288  | 0.0002288  | 0.0002288  |   0.0 |  0.00
Modify  | 1.3178     | 1.3178     | 1.3178     |   0.0 |  1.12
Other   |            | 0.161      |            |       |  0.14

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

Total # of neighbors = 350426
Ave neighs/atom = 43.803250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.499043273701, Press = 0.859967887715572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -36349.148   -36349.148    -36693.37    -36693.37    332.91875    332.91875    160403.28    160403.28    1133.6858    1133.6858 
   61000   -36345.111   -36345.111   -36687.319   -36687.319     330.9706     330.9706    160650.47    160650.47   -278.81392   -278.81392 
Loop time of 118.3 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.730 ns/day, 32.861 hours/ns, 8.453 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    | 116.6      | 116.6      | 116.6      |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21016    | 0.21016    | 0.21016    |   0.0 |  0.18
Output  | 0.00022456 | 0.00022456 | 0.00022456 |   0.0 |  0.00
Modify  | 1.3267     | 1.3267     | 1.3267     |   0.0 |  1.12
Other   |            | 0.162      |            |       |  0.14

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

Total # of neighbors = 351832
Ave neighs/atom = 43.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.479682140154, Press = 0.407349970654521
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -36345.111   -36345.111   -36687.319   -36687.319     330.9706     330.9706    160650.47    160650.47   -278.81392   -278.81392 
   62000   -36344.548   -36344.548   -36687.797   -36687.797    331.97796    331.97796    160647.44    160647.44   -226.85639   -226.85639 
Loop time of 118.513 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.729 ns/day, 32.920 hours/ns, 8.438 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    | 116.82     | 116.82     | 116.82     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20723    | 0.20723    | 0.20723    |   0.0 |  0.17
Output  | 0.00022663 | 0.00022663 | 0.00022663 |   0.0 |  0.00
Modify  | 1.3248     | 1.3248     | 1.3248     |   0.0 |  1.12
Other   |            | 0.1622     |            |       |  0.14

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

Total # of neighbors = 350668
Ave neighs/atom = 43.833500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.475215735522, Press = 0.855517698586909
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -36344.548   -36344.548   -36687.797   -36687.797    331.97796    331.97796    160647.44    160647.44   -226.85639   -226.85639 
   63000    -36348.44    -36348.44    -36692.95    -36692.95    333.19728    333.19728    160500.96    160500.96    574.23948    574.23948 
Loop time of 127.45 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.678 ns/day, 35.403 hours/ns, 7.846 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.59     | 125.59     | 125.59     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21653    | 0.21653    | 0.21653    |   0.0 |  0.17
Output  | 0.00027885 | 0.00027885 | 0.00027885 |   0.0 |  0.00
Modify  | 1.4747     | 1.4747     | 1.4747     |   0.0 |  1.16
Other   |            | 0.1711     |            |       |  0.13

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

Total # of neighbors = 350572
Ave neighs/atom = 43.821500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.474751464307, Press = 0.554525267408455
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000    -36348.44    -36348.44    -36692.95    -36692.95    333.19728    333.19728    160500.96    160500.96    574.23948    574.23948 
   64000   -36346.072   -36346.072   -36689.154   -36689.154    331.81677    331.81677    160713.53    160713.53   -641.80935   -641.80935 
Loop time of 139.002 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.612 hours/ns, 7.194 timesteps/s
100.0% 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 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22828    | 0.22828    | 0.22828    |   0.0 |  0.16
Output  | 0.00022833 | 0.00022833 | 0.00022833 |   0.0 |  0.00
Modify  | 1.6651     | 1.6651     | 1.6651     |   0.0 |  1.20
Other   |            | 0.1819     |            |       |  0.13

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

Total # of neighbors = 351270
Ave neighs/atom = 43.908750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.484261502618, Press = 0.362739430212816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -36346.072   -36346.072   -36689.154   -36689.154    331.81677    331.81677    160713.53    160713.53   -641.80935   -641.80935 
   65000   -36345.787   -36345.787   -36687.786   -36687.786    330.76887    330.76887    160554.66    160554.66    305.59107    305.59107 
Loop time of 122.229 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.707 ns/day, 33.952 hours/ns, 8.181 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.46     | 120.46     | 120.46     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21262    | 0.21262    | 0.21262    |   0.0 |  0.17
Output  | 0.00022476 | 0.00022476 | 0.00022476 |   0.0 |  0.00
Modify  | 1.3922     | 1.3922     | 1.3922     |   0.0 |  1.14
Other   |            | 0.1646     |            |       |  0.13

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

Total # of neighbors = 350452
Ave neighs/atom = 43.806500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.469906999018, Press = 1.5192002647078
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -36345.787   -36345.787   -36687.786   -36687.786    330.76887    330.76887    160554.66    160554.66    305.59107    305.59107 
   66000   -36345.204   -36345.204   -36691.056   -36691.056    334.49522    334.49522    160476.67    160476.67    813.21726    813.21726 
Loop time of 129.63 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.667 ns/day, 36.008 hours/ns, 7.714 timesteps/s
100.0% 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.72     | 127.72     | 127.72     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21901    | 0.21901    | 0.21901    |   0.0 |  0.17
Output  | 0.00027509 | 0.00027509 | 0.00027509 |   0.0 |  0.00
Modify  | 1.5149     | 1.5149     | 1.5149     |   0.0 |  1.17
Other   |            | 0.1726     |            |       |  0.13

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

Total # of neighbors = 351002
Ave neighs/atom = 43.875250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.465831162911, Press = 0.314557534758165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -36345.204   -36345.204   -36691.056   -36691.056    334.49522    334.49522    160476.67    160476.67    813.21726    813.21726 
   67000   -36347.155   -36347.155   -36690.708   -36690.708    332.27158    332.27158    160713.49    160713.49   -715.86177   -715.86177 
Loop time of 138.933 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.592 hours/ns, 7.198 timesteps/s
100.0% 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.85     | 136.85     | 136.85     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22835    | 0.22835    | 0.22835    |   0.0 |  0.16
Output  | 0.00022545 | 0.00022545 | 0.00022545 |   0.0 |  0.00
Modify  | 1.6762     | 1.6762     | 1.6762     |   0.0 |  1.21
Other   |            | 0.1821     |            |       |  0.13

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

Total # of neighbors = 351438
Ave neighs/atom = 43.929750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.44912417838, Press = 0.604283488226539
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -36347.155   -36347.155   -36690.708   -36690.708    332.27158    332.27158    160713.49    160713.49   -715.86177   -715.86177 
   68000   -36339.685   -36339.685   -36681.138   -36681.138     330.2408     330.2408    160550.71    160550.71    298.51869    298.51869 
Loop time of 138.78 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.623 ns/day, 38.550 hours/ns, 7.206 timesteps/s
100.0% 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.7      | 136.7      | 136.7      |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22692    | 0.22692    | 0.22692    |   0.0 |  0.16
Output  | 0.00023765 | 0.00023765 | 0.00023765 |   0.0 |  0.00
Modify  | 1.6743     | 1.6743     | 1.6743     |   0.0 |  1.21
Other   |            | 0.1821     |            |       |  0.13

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

Total # of neighbors = 350342
Ave neighs/atom = 43.792750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.446769543994, Press = 0.764653868858697
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -36339.685   -36339.685   -36681.138   -36681.138     330.2408     330.2408    160550.71    160550.71    298.51869    298.51869 
   69000   -36349.354   -36349.354   -36692.518   -36692.518    331.89551    331.89551    160575.12    160575.12    113.13221    113.13221 
Loop time of 138.771 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.623 ns/day, 38.547 hours/ns, 7.206 timesteps/s
100.0% 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.7      | 136.7      | 136.7      |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22597    | 0.22597    | 0.22597    |   0.0 |  0.16
Output  | 0.00023536 | 0.00023536 | 0.00023536 |   0.0 |  0.00
Modify  | 1.6632     | 1.6632     | 1.6632     |   0.0 |  1.20
Other   |            | 0.1819     |            |       |  0.13

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

Total # of neighbors = 350514
Ave neighs/atom = 43.814250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4576723, Press = 0.395119727672902
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -36349.354   -36349.354   -36692.518   -36692.518    331.89551    331.89551    160575.12    160575.12    113.13221    113.13221 
   70000   -36339.184   -36339.184   -36685.442   -36685.442    334.88807    334.88807     160718.5     160718.5   -714.15597   -714.15597 
Loop time of 138.657 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.623 ns/day, 38.516 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    | 136.57     | 136.57     | 136.57     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22569    | 0.22569    | 0.22569    |   0.0 |  0.16
Output  | 0.00027265 | 0.00027265 | 0.00027265 |   0.0 |  0.00
Modify  | 1.6747     | 1.6747     | 1.6747     |   0.0 |  1.21
Other   |            | 0.1822     |            |       |  0.13

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

Total # of neighbors = 350982
Ave neighs/atom = 43.872750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.466993942747, Press = 0.586467173467606
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -36339.184   -36339.184   -36685.442   -36685.442    334.88807    334.88807     160718.5     160718.5   -714.15597   -714.15597 
   71000   -36350.449   -36350.449   -36692.439   -36692.439    330.75984    330.75984    160424.88    160424.88    1019.8658    1019.8658 
Loop time of 126.658 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.8      | 124.8      | 124.8      |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2137     | 0.2137     | 0.2137     |   0.0 |  0.17
Output  | 0.00052105 | 0.00052105 | 0.00052105 |   0.0 |  0.00
Modify  | 1.4688     | 1.4688     | 1.4688     |   0.0 |  1.16
Other   |            | 0.1715     |            |       |  0.14

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

Total # of neighbors = 350348
Ave neighs/atom = 43.793500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4765323656, Press = 0.957641546344474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -36350.449   -36350.449   -36692.439   -36692.439    330.75984    330.75984    160424.88    160424.88    1019.8658    1019.8658 
   72000   -36342.353   -36342.353   -36691.184   -36691.184    337.37703    337.37703    160603.78    160603.78   -31.314376   -31.314376 
Loop time of 117.521 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.645 hours/ns, 8.509 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.84     | 115.84     | 115.84     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20718    | 0.20718    | 0.20718    |   0.0 |  0.18
Output  | 0.00027416 | 0.00027416 | 0.00027416 |   0.0 |  0.00
Modify  | 1.3154     | 1.3154     | 1.3154     |   0.0 |  1.12
Other   |            | 0.1615     |            |       |  0.14

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

Total # of neighbors = 351526
Ave neighs/atom = 43.940750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.476303857133, Press = 0.111299445792045
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -36342.353   -36342.353   -36691.184   -36691.184    337.37703    337.37703    160603.78    160603.78   -31.314376   -31.314376 
   73000   -36346.875   -36346.875   -36691.767   -36691.767    333.56685    333.56685    160659.86    160659.86   -402.97845   -402.97845 
Loop time of 117.673 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.687 hours/ns, 8.498 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.99     | 115.99     | 115.99     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20658    | 0.20658    | 0.20658    |   0.0 |  0.18
Output  | 0.00022523 | 0.00022523 | 0.00022523 |   0.0 |  0.00
Modify  | 1.3183     | 1.3183     | 1.3183     |   0.0 |  1.12
Other   |            | 0.1614     |            |       |  0.14

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

Total # of neighbors = 350948
Ave neighs/atom = 43.868500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.474227559567, Press = 0.745884686636618
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -36346.875   -36346.875   -36691.767   -36691.767    333.56685    333.56685    160659.86    160659.86   -402.97845   -402.97845 
   74000   -36346.323   -36346.323       -36691       -36691    333.35906    333.35906    160496.91    160496.91    589.29179    589.29179 
Loop time of 129.162 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.669 ns/day, 35.878 hours/ns, 7.742 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.26     | 127.26     | 127.26     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21877    | 0.21877    | 0.21877    |   0.0 |  0.17
Output  | 0.00027972 | 0.00027972 | 0.00027972 |   0.0 |  0.00
Modify  | 1.5072     | 1.5072     | 1.5072     |   0.0 |  1.17
Other   |            | 0.1746     |            |       |  0.14

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

Total # of neighbors = 350882
Ave neighs/atom = 43.860250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.493375049511, Press = 0.625242022501669
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -36346.323   -36346.323       -36691       -36691    333.35906    333.35906    160496.91    160496.91    589.29179    589.29179 
   75000   -36343.727   -36343.727   -36693.119   -36693.119    337.91919    337.91919    160660.94    160660.94   -400.88922   -400.88922 
Loop time of 139.003 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.612 hours/ns, 7.194 timesteps/s
100.0% 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.92     | 136.92     | 136.92     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22708    | 0.22708    | 0.22708    |   0.0 |  0.16
Output  | 0.00028783 | 0.00028783 | 0.00028783 |   0.0 |  0.00
Modify  | 1.6718     | 1.6718     | 1.6718     |   0.0 |  1.20
Other   |            | 0.1846     |            |       |  0.13

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

Total # of neighbors = 351356
Ave neighs/atom = 43.919500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.490445590379, Press = 0.270403081550807
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -36343.727   -36343.727   -36693.119   -36693.119    337.91919    337.91919    160660.94    160660.94   -400.88922   -400.88922 
   76000   -36342.993   -36342.993   -36688.926   -36688.926    334.57346    334.57346    160637.17    160637.17   -234.34161   -234.34161 
Loop time of 138.544 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.624 ns/day, 38.484 hours/ns, 7.218 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.48     | 136.48     | 136.48     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22817    | 0.22817    | 0.22817    |   0.0 |  0.16
Output  | 0.00028936 | 0.00028936 | 0.00028936 |   0.0 |  0.00
Modify  | 1.6557     | 1.6557     | 1.6557     |   0.0 |  1.20
Other   |            | 0.1826     |            |       |  0.13

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

Total # of neighbors = 350708
Ave neighs/atom = 43.838500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.481317783046, Press = 0.795400678748365
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -36342.993   -36342.993   -36688.926   -36688.926    334.57346    334.57346    160637.17    160637.17   -234.34161   -234.34161 
   77000   -36338.623   -36338.623   -36687.247   -36687.247    337.17662    337.17662    160477.54    160477.54    690.24674    690.24674 
Loop time of 139.457 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.620 ns/day, 38.738 hours/ns, 7.171 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.37     | 137.37     | 137.37     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22846    | 0.22846    | 0.22846    |   0.0 |  0.16
Output  | 0.00027661 | 0.00027661 | 0.00027661 |   0.0 |  0.00
Modify  | 1.671      | 1.671      | 1.671      |   0.0 |  1.20
Other   |            | 0.184      |            |       |  0.13

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

Total # of neighbors = 350872
Ave neighs/atom = 43.859000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.466668693119, Press = 0.409708481862332
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -36338.623   -36338.623   -36687.247   -36687.247    337.17662    337.17662    160477.54    160477.54    690.24674    690.24674 
   78000   -36347.403   -36347.403    -36688.37    -36688.37    329.77065    329.77065    160872.84    160872.84   -1666.5598   -1666.5598 
Loop time of 117.612 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.670 hours/ns, 8.503 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.93     | 115.93     | 115.93     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20343    | 0.20343    | 0.20343    |   0.0 |  0.17
Output  | 0.00022356 | 0.00022356 | 0.00022356 |   0.0 |  0.00
Modify  | 1.316      | 1.316      | 1.316      |   0.0 |  1.12
Other   |            | 0.1612     |            |       |  0.14

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

Total # of neighbors = 351088
Ave neighs/atom = 43.886000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.483156057679, Press = 0.165534942215487
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -36347.403   -36347.403    -36688.37    -36688.37    329.77065    329.77065    160872.84    160872.84   -1666.5598   -1666.5598 
   79000   -36342.024   -36342.024   -36688.009   -36688.009    334.62394    334.62394    160548.63    160548.63    283.94554    283.94554 
Loop time of 127.145 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.680 ns/day, 35.318 hours/ns, 7.865 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.28     | 125.28     | 125.28     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21477    | 0.21477    | 0.21477    |   0.0 |  0.17
Output  | 0.00023088 | 0.00023088 | 0.00023088 |   0.0 |  0.00
Modify  | 1.4779     | 1.4779     | 1.4779     |   0.0 |  1.16
Other   |            | 0.1716     |            |       |  0.13

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

Total # of neighbors = 349894
Ave neighs/atom = 43.736750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.487858985887, Press = 0.913397049788266
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -36342.024   -36342.024   -36688.009   -36688.009    334.62394    334.62394    160548.63    160548.63    283.94554    283.94554 
   80000   -36352.765   -36352.765   -36693.915   -36693.915    329.94802    329.94802    160538.38    160538.38    281.57993    281.57993 
Loop time of 139.532 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.619 ns/day, 38.759 hours/ns, 7.167 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.45     | 137.45     | 137.45     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22909    | 0.22909    | 0.22909    |   0.0 |  0.16
Output  | 0.00022361 | 0.00022361 | 0.00022361 |   0.0 |  0.00
Modify  | 1.6689     | 1.6689     | 1.6689     |   0.0 |  1.20
Other   |            | 0.183      |            |       |  0.13

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

Total # of neighbors = 350972
Ave neighs/atom = 43.871500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.480378268834, Press = 0.356655966721295
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -36352.765   -36352.765   -36693.915   -36693.915    329.94802    329.94802    160538.38    160538.38    281.57993    281.57993 
   81000   -36344.072   -36344.072   -36688.467   -36688.467     333.0864     333.0864    160658.05    160658.05   -329.87677   -329.87677 
Loop time of 139.505 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.619 ns/day, 38.751 hours/ns, 7.168 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.42     | 137.42     | 137.42     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22986    | 0.22986    | 0.22986    |   0.0 |  0.16
Output  | 0.00022577 | 0.00022577 | 0.00022577 |   0.0 |  0.00
Modify  | 1.671      | 1.671      | 1.671      |   0.0 |  1.20
Other   |            | 0.1831     |            |       |  0.13

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

Total # of neighbors = 351202
Ave neighs/atom = 43.900250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456036075402, Press = 0.600932202793173
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -36344.072   -36344.072   -36688.467   -36688.467     333.0864     333.0864    160658.05    160658.05   -329.87677   -329.87677 
   82000   -36353.793   -36353.793   -36694.904   -36694.904    329.90965    329.90965    160475.68    160475.68    669.73127    669.73127 
Loop time of 139.379 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.620 ns/day, 38.716 hours/ns, 7.175 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.28     | 137.28     | 137.28     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22855    | 0.22855    | 0.22855    |   0.0 |  0.16
Output  | 0.00022743 | 0.00022743 | 0.00022743 |   0.0 |  0.00
Modify  | 1.6835     | 1.6835     | 1.6835     |   0.0 |  1.21
Other   |            | 0.1822     |            |       |  0.13

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

Total # of neighbors = 350638
Ave neighs/atom = 43.829750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.443881077124, Press = 0.677786010955845
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -36353.793   -36353.793   -36694.904   -36694.904    329.90965    329.90965    160475.68    160475.68    669.73127    669.73127 
   83000   -36342.945   -36342.945   -36688.081   -36688.081    333.80244    333.80244    160640.07    160640.07   -225.69127   -225.69127 
Loop time of 139.571 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.619 ns/day, 38.770 hours/ns, 7.165 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.49     | 137.49     | 137.49     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22882    | 0.22882    | 0.22882    |   0.0 |  0.16
Output  | 0.00032816 | 0.00032816 | 0.00032816 |   0.0 |  0.00
Modify  | 1.6666     | 1.6666     | 1.6666     |   0.0 |  1.19
Other   |            | 0.1823     |            |       |  0.13

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

Total # of neighbors = 351574
Ave neighs/atom = 43.946750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.42799966402, Press = 0.120670124592426
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -36342.945   -36342.945   -36688.081   -36688.081    333.80244    333.80244    160640.07    160640.07   -225.69127   -225.69127 
   84000   -36349.486   -36349.486   -36691.644   -36691.644    330.92248    330.92248     160726.5     160726.5   -799.60741   -799.60741 
Loop time of 118.732 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.728 ns/day, 32.981 hours/ns, 8.422 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    | 117.03     | 117.03     | 117.03     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20792    | 0.20792    | 0.20792    |   0.0 |  0.18
Output  | 0.00022424 | 0.00022424 | 0.00022424 |   0.0 |  0.00
Modify  | 1.3282     | 1.3282     | 1.3282     |   0.0 |  1.12
Other   |            | 0.1613     |            |       |  0.14

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

Total # of neighbors = 350846
Ave neighs/atom = 43.855750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.426279456456, Press = 0.945847479463099
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -36349.486   -36349.486   -36691.644   -36691.644    330.92248    330.92248     160726.5     160726.5   -799.60741   -799.60741 
   85000   -36342.204   -36342.204   -36691.075   -36691.075    337.41484    337.41484     160485.4     160485.4    713.79898    713.79898 
Loop time of 118.333 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.730 ns/day, 32.870 hours/ns, 8.451 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    | 116.64     | 116.64     | 116.64     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20712    | 0.20712    | 0.20712    |   0.0 |  0.18
Output  | 0.00022674 | 0.00022674 | 0.00022674 |   0.0 |  0.00
Modify  | 1.3208     | 1.3208     | 1.3208     |   0.0 |  1.12
Other   |            | 0.1609     |            |       |  0.14

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

Total # of neighbors = 350580
Ave neighs/atom = 43.822500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.420657416983, Press = 0.515914344980962
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -36342.204   -36342.204   -36691.075   -36691.075    337.41484    337.41484     160485.4     160485.4    713.79898    713.79898 
   86000   -36345.352   -36345.352   -36690.309   -36690.309     333.6294     333.6294    160664.22    160664.22   -419.37299   -419.37299 
Loop time of 117.635 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.676 hours/ns, 8.501 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.95     | 115.95     | 115.95     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20261    | 0.20261    | 0.20261    |   0.0 |  0.17
Output  | 0.0002251  | 0.0002251  | 0.0002251  |   0.0 |  0.00
Modify  | 1.319      | 1.319      | 1.319      |   0.0 |  1.12
Other   |            | 0.1625     |            |       |  0.14

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

Total # of neighbors = 351240
Ave neighs/atom = 43.905000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.414193155393, Press = 0.361436205788122
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -36345.352   -36345.352   -36690.309   -36690.309     333.6294     333.6294    160664.22    160664.22   -419.37299   -419.37299 
   87000   -36338.412   -36338.412     -36689.8     -36689.8    339.84989    339.84989     160628.9     160628.9   -150.72375   -150.72375 
Loop time of 138.542 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.624 ns/day, 38.484 hours/ns, 7.218 timesteps/s
100.0% 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.47     | 136.47     | 136.47     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22852    | 0.22852    | 0.22852    |   0.0 |  0.16
Output  | 0.00034773 | 0.00034773 | 0.00034773 |   0.0 |  0.00
Modify  | 1.6639     | 1.6639     | 1.6639     |   0.0 |  1.20
Other   |            | 0.1832     |            |       |  0.13

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

Total # of neighbors = 350486
Ave neighs/atom = 43.810750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.433541445441, Press = 0.728199543318966
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -36338.412   -36338.412     -36689.8     -36689.8    339.84989    339.84989     160628.9     160628.9   -150.72375   -150.72375 
   88000    -36348.72    -36348.72   -36691.309   -36691.309    331.33885    331.33885    160447.77    160447.77    859.39357    859.39357 
Loop time of 119.051 on 1 procs for 1000 steps with 8000 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    | 117.34     | 117.34     | 117.34     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20939    | 0.20939    | 0.20939    |   0.0 |  0.18
Output  | 0.00022377 | 0.00022377 | 0.00022377 |   0.0 |  0.00
Modify  | 1.3396     | 1.3396     | 1.3396     |   0.0 |  1.13
Other   |            | 0.1635     |            |       |  0.14

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

Total # of neighbors = 350936
Ave neighs/atom = 43.867000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.435000987743, Press = 0.36711265884155
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000    -36348.72    -36348.72   -36691.309   -36691.309    331.33885    331.33885    160447.77    160447.77    859.39357    859.39357 
   89000   -36345.938   -36345.938   -36687.419   -36687.419    330.26863    330.26863    160817.21    160817.21   -1280.1766   -1280.1766 
Loop time of 117.282 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.578 hours/ns, 8.526 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.6      | 115.6      | 115.6      |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20439    | 0.20439    | 0.20439    |   0.0 |  0.17
Output  | 0.00022311 | 0.00022311 | 0.00022311 |   0.0 |  0.00
Modify  | 1.3135     | 1.3135     | 1.3135     |   0.0 |  1.12
Other   |            | 0.1623     |            |       |  0.14

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

Total # of neighbors = 351338
Ave neighs/atom = 43.917250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.440384072797, Press = 0.284231476749994
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -36345.938   -36345.938   -36687.419   -36687.419    330.26863    330.26863    160817.21    160817.21   -1280.1766   -1280.1766 
   90000   -36345.365   -36345.365   -36689.799   -36689.799     333.1233     333.1233    160578.96    160578.96    149.62069    149.62069 
Loop time of 117.112 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.738 ns/day, 32.531 hours/ns, 8.539 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.43     | 115.43     | 115.43     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20319    | 0.20319    | 0.20319    |   0.0 |  0.17
Output  | 0.00028411 | 0.00028411 | 0.00028411 |   0.0 |  0.00
Modify  | 1.3135     | 1.3135     | 1.3135     |   0.0 |  1.12
Other   |            | 0.1641     |            |       |  0.14

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

Total # of neighbors = 349840
Ave neighs/atom = 43.730000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.425381515971, Press = 0.68557788637332
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -36345.365   -36345.365   -36689.799   -36689.799     333.1233     333.1233    160578.96    160578.96    149.62069    149.62069 
   91000   -36346.723   -36346.723   -36691.431   -36691.431    333.38861    333.38861    160577.89    160577.89    126.32796    126.32796 
Loop time of 117.219 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.561 hours/ns, 8.531 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.54     | 115.54     | 115.54     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20253    | 0.20253    | 0.20253    |   0.0 |  0.17
Output  | 0.00022486 | 0.00022486 | 0.00022486 |   0.0 |  0.00
Modify  | 1.3123     | 1.3123     | 1.3123     |   0.0 |  1.12
Other   |            | 0.1621     |            |       |  0.14

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

Total # of neighbors = 351012
Ave neighs/atom = 43.876500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.413683294387, Press = 0.40428148962214
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -36346.723   -36346.723   -36691.431   -36691.431    333.38861    333.38861    160577.89    160577.89    126.32796    126.32796 
   92000   -36339.469   -36339.469   -36689.258   -36689.258     338.3022     338.3022    160643.79    160643.79   -273.81004   -273.81004 
Loop time of 117.41 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.73     | 115.73     | 115.73     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20577    | 0.20577    | 0.20577    |   0.0 |  0.18
Output  | 0.00027764 | 0.00027764 | 0.00027764 |   0.0 |  0.00
Modify  | 1.3145     | 1.3145     | 1.3145     |   0.0 |  1.12
Other   |            | 0.1618     |            |       |  0.14

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

Total # of neighbors = 350960
Ave neighs/atom = 43.870000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.397614464276, Press = 0.516959858895705
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -36339.469   -36339.469   -36689.258   -36689.258     338.3022     338.3022    160643.79    160643.79   -273.81004   -273.81004 
   93000   -36348.107   -36348.107   -36694.316   -36694.316    334.83976    334.83976    160500.69    160500.69    540.13849    540.13849 
Loop time of 117.638 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.677 hours/ns, 8.501 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.95     | 115.95     | 115.95     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20808    | 0.20808    | 0.20808    |   0.0 |  0.18
Output  | 0.00022472 | 0.00022472 | 0.00022472 |   0.0 |  0.00
Modify  | 1.3147     | 1.3147     | 1.3147     |   0.0 |  1.12
Other   |            | 0.1614     |            |       |  0.14

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

Total # of neighbors = 350594
Ave neighs/atom = 43.824250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.395051812692, Press = 0.543790615222368
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -36348.107   -36348.107   -36694.316   -36694.316    334.83976    334.83976    160500.69    160500.69    540.13849    540.13849 
   94000   -36342.118   -36342.118   -36686.777   -36686.777     333.3416     333.3416    160655.62    160655.62   -252.07353   -252.07353 
Loop time of 118.242 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.731 ns/day, 32.845 hours/ns, 8.457 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    | 116.56     | 116.56     | 116.56     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20603    | 0.20603    | 0.20603    |   0.0 |  0.17
Output  | 0.00033743 | 0.00033743 | 0.00033743 |   0.0 |  0.00
Modify  | 1.3191     | 1.3191     | 1.3191     |   0.0 |  1.12
Other   |            | 0.1618     |            |       |  0.14

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

Total # of neighbors = 351376
Ave neighs/atom = 43.922000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.394542593405, Press = 0.151006098332497
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -36342.118   -36342.118   -36686.777   -36686.777     333.3416     333.3416    160655.62    160655.62   -252.07353   -252.07353 
   95000   -36345.833   -36345.833    -36690.82    -36690.82    333.65884    333.65884    160682.66    160682.66   -408.50912   -408.50912 
Loop time of 132.929 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.650 ns/day, 36.925 hours/ns, 7.523 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    | 130.97     | 130.97     | 130.97     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22215    | 0.22215    | 0.22215    |   0.0 |  0.17
Output  | 0.00022769 | 0.00022769 | 0.00022769 |   0.0 |  0.00
Modify  | 1.5588     | 1.5588     | 1.5588     |   0.0 |  1.17
Other   |            | 0.1785     |            |       |  0.13

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

Total # of neighbors = 350820
Ave neighs/atom = 43.852500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.394548695309, Press = 0.700395467000474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -36345.833   -36345.833    -36690.82    -36690.82    333.65884    333.65884    160682.66    160682.66   -408.50912   -408.50912 
   96000   -36345.668   -36345.668   -36686.786   -36686.786    329.91718    329.91718    160486.67    160486.67    726.84929    726.84929 
Loop time of 122.216 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.707 ns/day, 33.949 hours/ns, 8.182 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    | 120.45     | 120.45     | 120.45     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21092    | 0.21092    | 0.21092    |   0.0 |  0.17
Output  | 0.0002768  | 0.0002768  | 0.0002768  |   0.0 |  0.00
Modify  | 1.385      | 1.385      | 1.385      |   0.0 |  1.13
Other   |            | 0.1653     |            |       |  0.14

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

Total # of neighbors = 350620
Ave neighs/atom = 43.827500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.409586905478, Press = 0.432273220764928
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -36345.668   -36345.668   -36686.786   -36686.786    329.91718    329.91718    160486.67    160486.67    726.84929    726.84929 
   97000   -36339.818   -36339.818   -36690.939   -36690.939    339.59112    339.59112    160678.05    160678.05   -325.94309   -325.94309 
Loop time of 118.389 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.730 ns/day, 32.886 hours/ns, 8.447 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    | 116.71     | 116.71     | 116.71     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20453    | 0.20453    | 0.20453    |   0.0 |  0.17
Output  | 0.000225   | 0.000225   | 0.000225   |   0.0 |  0.00
Modify  | 1.3172     | 1.3172     | 1.3172     |   0.0 |  1.11
Other   |            | 0.1611     |            |       |  0.14

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

Total # of neighbors = 351300
Ave neighs/atom = 43.912500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.413875037053, Press = 0.343877995116474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -36339.818   -36339.818   -36690.939   -36690.939    339.59112    339.59112    160678.05    160678.05   -325.94309   -325.94309 
   98000   -36348.286   -36348.286   -36693.533   -36693.533    333.91023    333.91023    160605.59    160605.59   -60.393312   -60.393312 
Loop time of 129.312 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.668 ns/day, 35.920 hours/ns, 7.733 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.42     | 127.42     | 127.42     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21713    | 0.21713    | 0.21713    |   0.0 |  0.17
Output  | 0.00022758 | 0.00022758 | 0.00022758 |   0.0 |  0.00
Modify  | 1.506      | 1.506      | 1.506      |   0.0 |  1.16
Other   |            | 0.1721     |            |       |  0.13

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

Total # of neighbors = 351122
Ave neighs/atom = 43.890250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.425529388631, Press = 0.512374464383651
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -36348.286   -36348.286   -36693.533   -36693.533    333.91023    333.91023    160605.59    160605.59   -60.393312   -60.393312 
   99000    -36338.85    -36338.85   -36686.889   -36686.889    336.61038    336.61038    160601.37    160601.37    35.229085    35.229085 
Loop time of 117.6 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.667 hours/ns, 8.503 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.92     | 115.92     | 115.92     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20634    | 0.20634    | 0.20634    |   0.0 |  0.18
Output  | 0.00022621 | 0.00022621 | 0.00022621 |   0.0 |  0.00
Modify  | 1.3104     | 1.3104     | 1.3104     |   0.0 |  1.11
Other   |            | 0.1593     |            |       |  0.14

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

Total # of neighbors = 351022
Ave neighs/atom = 43.877750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.43299914241, Press = 0.470620557168765
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000    -36338.85    -36338.85   -36686.889   -36686.889    336.61038    336.61038    160601.37    160601.37    35.229085    35.229085 
  100000   -36346.062   -36346.062   -36687.178   -36687.178    329.91478    329.91478    160595.02    160595.02    30.081337    30.081337 
Loop time of 117.675 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.688 hours/ns, 8.498 timesteps/s
100.0% 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        | 116        | 116        |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20593    | 0.20593    | 0.20593    |   0.0 |  0.17
Output  | 0.00022484 | 0.00022484 | 0.00022484 |   0.0 |  0.00
Modify  | 1.3121     | 1.3121     | 1.3121     |   0.0 |  1.12
Other   |            | 0.1589     |            |       |  0.14

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

Total # of neighbors = 350876
Ave neighs/atom = 43.859500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.431957977341, Press = 0.355015399050779
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -36346.062   -36346.062   -36687.178   -36687.178    329.91478    329.91478    160595.02    160595.02    30.081337    30.081337 
  101000   -36347.021   -36347.021    -36690.66    -36690.66    332.35489    332.35489     160636.5     160636.5   -232.58673   -232.58673 
Loop time of 117.572 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.659 hours/ns, 8.505 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.89     | 115.89     | 115.89     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20794    | 0.20794    | 0.20794    |   0.0 |  0.18
Output  | 0.00022915 | 0.00022915 | 0.00022915 |   0.0 |  0.00
Modify  | 1.3103     | 1.3103     | 1.3103     |   0.0 |  1.11
Other   |            | 0.1592     |            |       |  0.14

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

Total # of neighbors = 350946
Ave neighs/atom = 43.868250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.42183435713, Press = 0.439446033768979
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -36347.021   -36347.021    -36690.66    -36690.66    332.35489    332.35489     160636.5     160636.5   -232.58673   -232.58673 
  102000   -36343.541   -36343.541   -36687.321   -36687.321    332.49181    332.49181     160527.8     160527.8    396.72833    396.72833 
Loop time of 128.844 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.671 ns/day, 35.790 hours/ns, 7.761 timesteps/s
100.0% 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.96     | 126.96     | 126.96     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21697    | 0.21697    | 0.21697    |   0.0 |  0.17
Output  | 0.00027133 | 0.00027133 | 0.00027133 |   0.0 |  0.00
Modify  | 1.5006     | 1.5006     | 1.5006     |   0.0 |  1.16
Other   |            | 0.171      |            |       |  0.13

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

Total # of neighbors = 350740
Ave neighs/atom = 43.842500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.402889403142, Press = 0.435939891005068
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -36343.541   -36343.541   -36687.321   -36687.321    332.49181    332.49181     160527.8     160527.8    396.72833    396.72833 
  103000   -36348.482   -36348.482   -36686.176   -36686.176    326.60487    326.60487    160659.09    160659.09   -457.23567   -457.23567 
Loop time of 138.806 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.557 hours/ns, 7.204 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.74     | 136.74     | 136.74     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22555    | 0.22555    | 0.22555    |   0.0 |  0.16
Output  | 0.00022415 | 0.00022415 | 0.00022415 |   0.0 |  0.00
Modify  | 1.6597     | 1.6597     | 1.6597     |   0.0 |  1.20
Other   |            | 0.1821     |            |       |  0.13

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

Total # of neighbors = 350952
Ave neighs/atom = 43.869000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.398457609905, Press = 0.264908596686916
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -36348.482   -36348.482   -36686.176   -36686.176    326.60487    326.60487    160659.09    160659.09   -457.23567   -457.23567 
  104000   -36339.174   -36339.174   -36687.001   -36687.001    336.40625    336.40625     160619.9     160619.9   -83.582427   -83.582427 
Loop time of 138.685 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.623 ns/day, 38.523 hours/ns, 7.211 timesteps/s
100.0% 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.61     | 136.61     | 136.61     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22592    | 0.22592    | 0.22592    |   0.0 |  0.16
Output  | 0.00022536 | 0.00022536 | 0.00022536 |   0.0 |  0.00
Modify  | 1.6622     | 1.6622     | 1.6622     |   0.0 |  1.20
Other   |            | 0.182      |            |       |  0.13

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

Total # of neighbors = 350330
Ave neighs/atom = 43.791250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.39945422258, Press = 0.630619413862169
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -36339.174   -36339.174   -36687.001   -36687.001    336.40625    336.40625     160619.9     160619.9   -83.582427   -83.582427 
  105000   -36347.651   -36347.651   -36690.664   -36690.664    331.74932    331.74932    160475.43    160475.43    714.63644    714.63644 
Loop time of 139.304 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.620 ns/day, 38.696 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    | 137.22     | 137.22     | 137.22     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22736    | 0.22736    | 0.22736    |   0.0 |  0.16
Output  | 0.0002253  | 0.0002253  | 0.0002253  |   0.0 |  0.00
Modify  | 1.6758     | 1.6758     | 1.6758     |   0.0 |  1.20
Other   |            | 0.1845     |            |       |  0.13

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

Total # of neighbors = 350610
Ave neighs/atom = 43.826250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40036720318, Press = 0.330311020950613
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -36347.651   -36347.651   -36690.664   -36690.664    331.74932    331.74932    160475.43    160475.43    714.63644    714.63644 
  106000   -36340.118   -36340.118   -36686.752   -36686.752    335.25208    335.25208    160701.85    160701.85   -532.61601   -532.61601 
Loop time of 139.489 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.619 ns/day, 38.747 hours/ns, 7.169 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.4      | 137.4      | 137.4      |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22811    | 0.22811    | 0.22811    |   0.0 |  0.16
Output  | 0.00022727 | 0.00022727 | 0.00022727 |   0.0 |  0.00
Modify  | 1.679      | 1.679      | 1.679      |   0.0 |  1.20
Other   |            | 0.1849     |            |       |  0.13

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

Total # of neighbors = 351630
Ave neighs/atom = 43.953750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.412868223183, Press = 0.299156145493817
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000   -36340.118   -36340.118   -36686.752   -36686.752    335.25208    335.25208    160701.85    160701.85   -532.61601   -532.61601 
  107000    -36346.45    -36346.45   -36690.215   -36690.215     332.4765     332.4765     160546.7     160546.7    317.40002    317.40002 
Loop time of 123.835 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.698 ns/day, 34.398 hours/ns, 8.075 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    | 122.04     | 122.04     | 122.04     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21208    | 0.21208    | 0.21208    |   0.0 |  0.17
Output  | 0.00022635 | 0.00022635 | 0.00022635 |   0.0 |  0.00
Modify  | 1.4174     | 1.4174     | 1.4174     |   0.0 |  1.14
Other   |            | 0.1666     |            |       |  0.13

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

Total # of neighbors = 350450
Ave neighs/atom = 43.806250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.422923997107, Press = 0.611099107749808
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000    -36346.45    -36346.45   -36690.215   -36690.215     332.4765     332.4765     160546.7     160546.7    317.40002    317.40002 
  108000   -36342.744   -36342.744   -36690.213   -36690.213    336.05922    336.05922       160534       160534    432.50987    432.50987 
Loop time of 117.631 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.675 hours/ns, 8.501 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.95     | 115.95     | 115.95     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20845    | 0.20845    | 0.20845    |   0.0 |  0.18
Output  | 0.00027549 | 0.00027549 | 0.00027549 |   0.0 |  0.00
Modify  | 1.3144     | 1.3144     | 1.3144     |   0.0 |  1.12
Other   |            | 0.1616     |            |       |  0.14

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

Total # of neighbors = 351058
Ave neighs/atom = 43.882250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.425729799257, Press = 0.205432517005136
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -36342.744   -36342.744   -36690.213   -36690.213    336.05922    336.05922       160534       160534    432.50987    432.50987 
  109000   -36343.719   -36343.719   -36688.264   -36688.264    333.23061    333.23061    160762.33    160762.33   -978.50165   -978.50165 
Loop time of 117.637 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.677 hours/ns, 8.501 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.95     | 115.95     | 115.95     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20886    | 0.20886    | 0.20886    |   0.0 |  0.18
Output  | 0.00022653 | 0.00022653 | 0.00022653 |   0.0 |  0.00
Modify  | 1.3129     | 1.3129     | 1.3129     |   0.0 |  1.12
Other   |            | 0.1605     |            |       |  0.14

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

Total # of neighbors = 351174
Ave neighs/atom = 43.896750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.440225613114, Press = 0.442843135412811
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -36343.719   -36343.719   -36688.264   -36688.264    333.23061    333.23061    160762.33    160762.33   -978.50165   -978.50165 
  110000   -36342.869   -36342.869   -36689.709   -36689.709    335.45095    335.45095     160495.1     160495.1    583.28145    583.28145 
Loop time of 117.589 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.664 hours/ns, 8.504 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.91     | 115.91     | 115.91     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20802    | 0.20802    | 0.20802    |   0.0 |  0.18
Output  | 0.00027454 | 0.00027454 | 0.00027454 |   0.0 |  0.00
Modify  | 1.3127     | 1.3127     | 1.3127     |   0.0 |  1.12
Other   |            | 0.1607     |            |       |  0.14

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

Total # of neighbors = 350290
Ave neighs/atom = 43.786250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.442828471052, Press = 0.532293248689223
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -36342.869   -36342.869   -36689.709   -36689.709    335.45095    335.45095     160495.1     160495.1    583.28145    583.28145 
  111000   -36344.723   -36344.723   -36689.586   -36689.586    333.53878    333.53878    160591.28    160591.28    48.921196    48.921196 
Loop time of 117.687 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.691 hours/ns, 8.497 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116        | 116        | 116        |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20868    | 0.20868    | 0.20868    |   0.0 |  0.18
Output  | 0.00027346 | 0.00027346 | 0.00027346 |   0.0 |  0.00
Modify  | 1.3135     | 1.3135     | 1.3135     |   0.0 |  1.12
Other   |            | 0.1612     |            |       |  0.14

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

Total # of neighbors = 351146
Ave neighs/atom = 43.893250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.455007819571, Press = 0.265911006164165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -36344.723   -36344.723   -36689.586   -36689.586    333.53878    333.53878    160591.28    160591.28    48.921196    48.921196 
  112000   -36339.267   -36339.267   -36693.413   -36693.413    342.51765    342.51765    160658.59    160658.59   -322.27786   -322.27786 
Loop time of 138.765 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.623 ns/day, 38.546 hours/ns, 7.206 timesteps/s
100.0% 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.68     | 136.68     | 136.68     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22603    | 0.22603    | 0.22603    |   0.0 |  0.16
Output  | 0.00056025 | 0.00056025 | 0.00056025 |   0.0 |  0.00
Modify  | 1.6732     | 1.6732     | 1.6732     |   0.0 |  1.21
Other   |            | 0.1839     |            |       |  0.13

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

Total # of neighbors = 351080
Ave neighs/atom = 43.885000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.454357981299, Press = 0.443444156115031
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -36339.267   -36339.267   -36693.413   -36693.413    342.51765    342.51765    160658.59    160658.59   -322.27786   -322.27786 
  113000   -36349.963   -36349.963   -36692.115   -36692.115    330.91681    330.91681     160538.5     160538.5    369.04398    369.04398 
Loop time of 138.891 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.581 hours/ns, 7.200 timesteps/s
100.0% 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.8      | 136.8      | 136.8      |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22656    | 0.22656    | 0.22656    |   0.0 |  0.16
Output  | 0.00023073 | 0.00023073 | 0.00023073 |   0.0 |  0.00
Modify  | 1.6812     | 1.6812     | 1.6812     |   0.0 |  1.21
Other   |            | 0.1836     |            |       |  0.13

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

Total # of neighbors = 350844
Ave neighs/atom = 43.855500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.466339593723, Press = 0.386450724554783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -36349.963   -36349.963   -36692.115   -36692.115    330.91681    330.91681     160538.5     160538.5    369.04398    369.04398 
  114000   -36343.418   -36343.418   -36688.695   -36688.695    333.93882    333.93882    160669.02    160669.02   -370.77913   -370.77913 
Loop time of 139.12 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.03     | 137.03     | 137.03     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22766    | 0.22766    | 0.22766    |   0.0 |  0.16
Output  | 0.00023429 | 0.00023429 | 0.00023429 |   0.0 |  0.00
Modify  | 1.6817     | 1.6817     | 1.6817     |   0.0 |  1.21
Other   |            | 0.1843     |            |       |  0.13

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

Total # of neighbors = 351196
Ave neighs/atom = 43.899500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.457392581614, Press = 0.263150851827076
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000   -36343.418   -36343.418   -36688.695   -36688.695    333.93882    333.93882    160669.02    160669.02   -370.77913   -370.77913 
  115000   -36355.274   -36355.274   -36694.445   -36694.445    328.03313    328.03313    160600.39    160600.39   -105.49463   -105.49463 
Loop time of 139.089 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.621 ns/day, 38.636 hours/ns, 7.190 timesteps/s
100.0% 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        | 137        | 137        |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22642    | 0.22642    | 0.22642    |   0.0 |  0.16
Output  | 0.00028254 | 0.00028254 | 0.00028254 |   0.0 |  0.00
Modify  | 1.6775     | 1.6775     | 1.6775     |   0.0 |  1.21
Other   |            | 0.1838     |            |       |  0.13

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

Total # of neighbors = 350820
Ave neighs/atom = 43.852500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.441754782164, Press = 0.624177925291205
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -36355.274   -36355.274   -36694.445   -36694.445    328.03313    328.03313    160600.39    160600.39   -105.49463   -105.49463 
  116000   -36342.614   -36342.614   -36685.648   -36685.648    331.76968    331.76968    160483.92    160483.92    781.69717    781.69717 
Loop time of 138.958 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.600 hours/ns, 7.196 timesteps/s
100.0% 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.87     | 136.87     | 136.87     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22728    | 0.22728    | 0.22728    |   0.0 |  0.16
Output  | 0.00022598 | 0.00022598 | 0.00022598 |   0.0 |  0.00
Modify  | 1.6805     | 1.6805     | 1.6805     |   0.0 |  1.21
Other   |            | 0.184      |            |       |  0.13

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

Total # of neighbors = 351174
Ave neighs/atom = 43.896750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.434862004711, Press = 0.194030855217497
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -36342.614   -36342.614   -36685.648   -36685.648    331.76968    331.76968    160483.92    160483.92    781.69717    781.69717 
  117000   -36343.057   -36343.057   -36684.024   -36684.024    329.77059    329.77059    160721.78    160721.78   -679.13406   -679.13406 
Loop time of 139.019 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.621 ns/day, 38.616 hours/ns, 7.193 timesteps/s
100.0% 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 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22722    | 0.22722    | 0.22722    |   0.0 |  0.16
Output  | 0.00028591 | 0.00028591 | 0.00028591 |   0.0 |  0.00
Modify  | 1.677      | 1.677      | 1.677      |   0.0 |  1.21
Other   |            | 0.1842     |            |       |  0.13

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

Total # of neighbors = 351424
Ave neighs/atom = 43.928000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.423129017261, Press = 0.363815760683086
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -36343.057   -36343.057   -36684.024   -36684.024    329.77059    329.77059    160721.78    160721.78   -679.13406   -679.13406 
  118000   -36348.824   -36348.824   -36692.208   -36692.208    332.10846    332.10846    160550.63    160550.63    272.98841    272.98841 
Loop time of 138.803 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.556 hours/ns, 7.204 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.72     | 136.72     | 136.72     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22685    | 0.22685    | 0.22685    |   0.0 |  0.16
Output  | 0.00022674 | 0.00022674 | 0.00022674 |   0.0 |  0.00
Modify  | 1.6715     | 1.6715     | 1.6715     |   0.0 |  1.20
Other   |            | 0.1837     |            |       |  0.13

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

Total # of neighbors = 350276
Ave neighs/atom = 43.784500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.41203368704, Press = 0.424952177987113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -36348.824   -36348.824   -36692.208   -36692.208    332.10846    332.10846    160550.63    160550.63    272.98841    272.98841 
  119000   -36339.565   -36339.565   -36687.994   -36687.994    336.98808    336.98808    160597.94    160597.94    52.765661    52.765661 
Loop time of 139.025 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.621 ns/day, 38.618 hours/ns, 7.193 timesteps/s
100.0% 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.95     | 136.95     | 136.95     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22683    | 0.22683    | 0.22683    |   0.0 |  0.16
Output  | 0.00022955 | 0.00022955 | 0.00022955 |   0.0 |  0.00
Modify  | 1.6667     | 1.6667     | 1.6667     |   0.0 |  1.20
Other   |            | 0.1825     |            |       |  0.13

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

Total # of neighbors = 351226
Ave neighs/atom = 43.903250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.411660943254, Press = 0.31063264700623
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000   -36339.565   -36339.565   -36687.994   -36687.994    336.98808    336.98808    160597.94    160597.94    52.765661    52.765661 
  120000   -36352.398   -36352.398   -36693.612   -36693.612    330.00896    330.00896    160630.42    160630.42   -165.11118   -165.11118 
Loop time of 138.918 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.588 hours/ns, 7.198 timesteps/s
100.0% 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.84     | 136.84     | 136.84     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22541    | 0.22541    | 0.22541    |   0.0 |  0.16
Output  | 0.00022406 | 0.00022406 | 0.00022406 |   0.0 |  0.00
Modify  | 1.6671     | 1.6671     | 1.6671     |   0.0 |  1.20
Other   |            | 0.1825     |            |       |  0.13

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

Total # of neighbors = 350900
Ave neighs/atom = 43.862500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40967004883, Press = 0.335201382017693
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -36352.398   -36352.398   -36693.612   -36693.612    330.00896    330.00896    160630.42    160630.42   -165.11118   -165.11118 
  121000   -36342.258   -36342.258   -36689.617   -36689.617    335.95312    335.95312    160563.73    160563.73    253.35022    253.35022 
Loop time of 139.058 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.621 ns/day, 38.627 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    | 136.97     | 136.97     | 136.97     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22838    | 0.22838    | 0.22838    |   0.0 |  0.16
Output  | 0.00022997 | 0.00022997 | 0.00022997 |   0.0 |  0.00
Modify  | 1.6785     | 1.6785     | 1.6785     |   0.0 |  1.21
Other   |            | 0.1831     |            |       |  0.13

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

Total # of neighbors = 350938
Ave neighs/atom = 43.867250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.394073532116, Press = 0.384143938622606
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000   -36342.258   -36342.258   -36689.617   -36689.617    335.95312    335.95312    160563.73    160563.73    253.35022    253.35022 
  122000   -36344.477   -36344.477    -36687.73    -36687.73    331.98199    331.98199    160644.25    160644.25    -265.5513    -265.5513 
Loop time of 138.873 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.576 hours/ns, 7.201 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.79     | 136.79     | 136.79     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2272     | 0.2272     | 0.2272     |   0.0 |  0.16
Output  | 0.00028641 | 0.00028641 | 0.00028641 |   0.0 |  0.00
Modify  | 1.6739     | 1.6739     | 1.6739     |   0.0 |  1.21
Other   |            | 0.1837     |            |       |  0.13

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

Total # of neighbors = 351148
Ave neighs/atom = 43.893500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.386860941437, Press = 0.242022578176206
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  122000   -36344.477   -36344.477    -36687.73    -36687.73    331.98199    331.98199    160644.25    160644.25    -265.5513    -265.5513 
  123000   -36347.123   -36347.123   -36690.914   -36690.914     332.5024     332.5024    160633.58    160633.58   -213.56238   -213.56238 
Loop time of 138.939 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.594 hours/ns, 7.197 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.85     | 136.85     | 136.85     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22838    | 0.22838    | 0.22838    |   0.0 |  0.16
Output  | 0.00023112 | 0.00023112 | 0.00023112 |   0.0 |  0.00
Modify  | 1.6809     | 1.6809     | 1.6809     |   0.0 |  1.21
Other   |            | 0.1838     |            |       |  0.13

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

Total # of neighbors = 350670
Ave neighs/atom = 43.833750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.393913855344, Press = 0.510598679787355
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  123000   -36347.123   -36347.123   -36690.914   -36690.914     332.5024     332.5024    160633.58    160633.58   -213.56238   -213.56238 
  124000   -36337.299   -36337.299   -36684.113   -36684.113    335.42561    335.42561    160454.75    160454.75    919.67173    919.67173 
Loop time of 138.942 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.595 hours/ns, 7.197 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.86     | 136.86     | 136.86     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22783    | 0.22783    | 0.22783    |   0.0 |  0.16
Output  | 0.00022758 | 0.00022758 | 0.00022758 |   0.0 |  0.00
Modify  | 1.6739     | 1.6739     | 1.6739     |   0.0 |  1.20
Other   |            | 0.1828     |            |       |  0.13

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

Total # of neighbors = 350886
Ave neighs/atom = 43.860750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.397091853744, Press = 0.296500628102197
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  124000   -36337.299   -36337.299   -36684.113   -36684.113    335.42561    335.42561    160454.75    160454.75    919.67173    919.67173 
  125000   -36347.873   -36347.873    -36690.62    -36690.62    331.49215    331.49215    160718.45    160718.45   -712.86849   -712.86849 
Loop time of 139.001 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.611 hours/ns, 7.194 timesteps/s
100.0% 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.92     | 136.92     | 136.92     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2285     | 0.2285     | 0.2285     |   0.0 |  0.16
Output  | 0.00022714 | 0.00022714 | 0.00022714 |   0.0 |  0.00
Modify  | 1.6676     | 1.6676     | 1.6676     |   0.0 |  1.20
Other   |            | 0.1836     |            |       |  0.13

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

Total # of neighbors = 351406
Ave neighs/atom = 43.925750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.404068850085, Press = 0.247871123620852
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  125000   -36347.873   -36347.873    -36690.62    -36690.62    331.49215    331.49215    160718.45    160718.45   -712.86849   -712.86849 
  126000   -36340.176   -36340.176   -36684.896   -36684.896    333.40019    333.40019    160572.54    160572.54    203.02004    203.02004 
Loop time of 138.778 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.623 ns/day, 38.549 hours/ns, 7.206 timesteps/s
100.0% 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.69     | 136.69     | 136.69     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22667    | 0.22667    | 0.22667    |   0.0 |  0.16
Output  | 0.00029186 | 0.00029186 | 0.00029186 |   0.0 |  0.00
Modify  | 1.6728     | 1.6728     | 1.6728     |   0.0 |  1.21
Other   |            | 0.184      |            |       |  0.13

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

Total # of neighbors = 350574
Ave neighs/atom = 43.821750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.410498828704, Press = 0.425687550576314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  126000   -36340.176   -36340.176   -36684.896   -36684.896    333.40019    333.40019    160572.54    160572.54    203.02004    203.02004 
  127000   -36350.043   -36350.043   -36692.189   -36692.189    330.91084    330.91084    160567.12    160567.12    115.94618    115.94618 
Loop time of 138.87 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.575 hours/ns, 7.201 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.79     | 136.79     | 136.79     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22801    | 0.22801    | 0.22801    |   0.0 |  0.16
Output  | 0.0002295  | 0.0002295  | 0.0002295  |   0.0 |  0.00
Modify  | 1.6707     | 1.6707     | 1.6707     |   0.0 |  1.20
Other   |            | 0.1832     |            |       |  0.13

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

Total # of neighbors = 351018
Ave neighs/atom = 43.877250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.417166147548, Press = 0.301362698475026
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  127000   -36350.043   -36350.043   -36692.189   -36692.189    330.91084    330.91084    160567.12    160567.12    115.94618    115.94618 
  128000   -36345.571   -36345.571   -36690.228   -36690.228    333.33935    333.33935     160620.8     160620.8   -202.10665   -202.10665 
Loop time of 138.968 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.622 ns/day, 38.602 hours/ns, 7.196 timesteps/s
100.0% 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.88     | 136.88     | 136.88     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2258     | 0.2258     | 0.2258     |   0.0 |  0.16
Output  | 0.00022781 | 0.00022781 | 0.00022781 |   0.0 |  0.00
Modify  | 1.6751     | 1.6751     | 1.6751     |   0.0 |  1.21
Other   |            | 0.184      |            |       |  0.13

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

Total # of neighbors = 351308
Ave neighs/atom = 43.913500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.415429028689, Press = 0.296361146526919
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  128000   -36345.571   -36345.571   -36690.228   -36690.228    333.33935    333.33935     160620.8     160620.8   -202.10665   -202.10665 
  129000   -36345.912   -36345.912   -36689.918   -36689.918    332.71039    332.71039    160569.37    160569.37    210.09641    210.09641 
Loop time of 135.534 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.637 ns/day, 37.648 hours/ns, 7.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    | 133.51     | 133.51     | 133.51     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22178    | 0.22178    | 0.22178    |   0.0 |  0.16
Output  | 0.00022383 | 0.00022383 | 0.00022383 |   0.0 |  0.00
Modify  | 1.6172     | 1.6172     | 1.6172     |   0.0 |  1.19
Other   |            | 0.1795     |            |       |  0.13

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

Total # of neighbors = 351012
Ave neighs/atom = 43.876500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.415851067022, Press = 0.358154882181368
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  129000   -36345.912   -36345.912   -36689.918   -36689.918    332.71039    332.71039    160569.37    160569.37    210.09641    210.09641 
  130000   -36335.963   -36335.963   -36684.116   -36684.116    336.72113    336.72113    160577.24    160577.24    162.94563    162.94563 
Loop time of 120 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.720 ns/day, 33.333 hours/ns, 8.333 timesteps/s
100.0% 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.27     | 118.27     | 118.27     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.206      | 0.206      | 0.206      |   0.0 |  0.17
Output  | 0.00029422 | 0.00029422 | 0.00029422 |   0.0 |  0.00
Modify  | 1.3561     | 1.3561     | 1.3561     |   0.0 |  1.13
Other   |            | 0.1645     |            |       |  0.14

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

Total # of neighbors = 351212
Ave neighs/atom = 43.901500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.423282367282, Press = 0.214552822310062
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  130000   -36335.963   -36335.963   -36684.116   -36684.116    336.72113    336.72113    160577.24    160577.24    162.94563    162.94563 
  131000   -36351.065   -36351.065   -36693.365   -36693.365    331.05985    331.05985    160659.18    160659.18    -439.0854    -439.0854 
Loop time of 128.664 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.672 ns/day, 35.740 hours/ns, 7.772 timesteps/s
100.0% 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.77     | 126.77     | 126.77     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21553    | 0.21553    | 0.21553    |   0.0 |  0.17
Output  | 0.00022971 | 0.00022971 | 0.00022971 |   0.0 |  0.00
Modify  | 1.5023     | 1.5023     | 1.5023     |   0.0 |  1.17
Other   |            | 0.1732     |            |       |  0.13

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

Total # of neighbors = 350754
Ave neighs/atom = 43.844250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.424901602546, Press = 0.363179898108482
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  131000   -36351.065   -36351.065   -36693.365   -36693.365    331.05985    331.05985    160659.18    160659.18    -439.0854    -439.0854 
  132000    -36344.41    -36344.41   -36691.882   -36691.882    336.06164    336.06164    160452.06    160452.06    907.19456    907.19456 
Loop time of 117.599 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.666 hours/ns, 8.503 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.92     | 115.92     | 115.92     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20749    | 0.20749    | 0.20749    |   0.0 |  0.18
Output  | 0.00023531 | 0.00023531 | 0.00023531 |   0.0 |  0.00
Modify  | 1.3127     | 1.3127     | 1.3127     |   0.0 |  1.12
Other   |            | 0.161      |            |       |  0.14

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

Total # of neighbors = 350608
Ave neighs/atom = 43.826000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.417909741402, Press = 0.410171874039009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  132000    -36344.41    -36344.41   -36691.882   -36691.882    336.06164    336.06164    160452.06    160452.06    907.19456    907.19456 
  133000    -36347.56    -36347.56   -36686.642   -36686.642    327.94713    327.94713     160623.8     160623.8   -201.19485   -201.19485 
Loop time of 117.812 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.726 hours/ns, 8.488 timesteps/s
100.0% 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.13     | 116.13     | 116.13     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20643    | 0.20643    | 0.20643    |   0.0 |  0.18
Output  | 0.00023198 | 0.00023198 | 0.00023198 |   0.0 |  0.00
Modify  | 1.3171     | 1.3171     | 1.3171     |   0.0 |  1.12
Other   |            | 0.1613     |            |       |  0.14

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

Total # of neighbors = 351502
Ave neighs/atom = 43.937750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.415039203388, Press = 0.101674134040214
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  133000    -36347.56    -36347.56   -36686.642   -36686.642    327.94713    327.94713     160623.8     160623.8   -201.19485   -201.19485 
  134000   -36342.636   -36342.636   -36692.393   -36692.393    338.27148    338.27148    160690.88    160690.88   -483.94722   -483.94722 
Loop time of 117.749 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.708 hours/ns, 8.493 timesteps/s
100.0% 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.06     | 116.06     | 116.06     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20898    | 0.20898    | 0.20898    |   0.0 |  0.18
Output  | 0.00029981 | 0.00029981 | 0.00029981 |   0.0 |  0.00
Modify  | 1.3181     | 1.3181     | 1.3181     |   0.0 |  1.12
Other   |            | 0.1611     |            |       |  0.14

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

Total # of neighbors = 350696
Ave neighs/atom = 43.837000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.418639186205, Press = 0.454558492579571
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  134000   -36342.636   -36342.636   -36692.393   -36692.393    338.27148    338.27148    160690.88    160690.88   -483.94722   -483.94722 
  135000   -36341.312   -36341.312    -36690.38    -36690.38    337.60582    337.60582     160529.6     160529.6    447.74035    447.74035 
Loop time of 117.739 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.705 hours/ns, 8.493 timesteps/s
100.0% 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.05     | 116.05     | 116.05     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20776    | 0.20776    | 0.20776    |   0.0 |  0.18
Output  | 0.00027697 | 0.00027697 | 0.00027697 |   0.0 |  0.00
Modify  | 1.3197     | 1.3197     | 1.3197     |   0.0 |  1.12
Other   |            | 0.1619     |            |       |  0.14

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

Total # of neighbors = 350682
Ave neighs/atom = 43.835250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.413824539233, Press = 0.298713336700918
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  135000   -36341.312   -36341.312    -36690.38    -36690.38    337.60582    337.60582     160529.6     160529.6    447.74035    447.74035 
  136000   -36346.964   -36346.964   -36690.383   -36690.383    332.14251    332.14251    160613.39    160613.39   -126.38075   -126.38075 
Loop time of 117.756 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.710 hours/ns, 8.492 timesteps/s
100.0% 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.07     | 116.07     | 116.07     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20714    | 0.20714    | 0.20714    |   0.0 |  0.18
Output  | 0.00022409 | 0.00022409 | 0.00022409 |   0.0 |  0.00
Modify  | 1.3184     | 1.3184     | 1.3184     |   0.0 |  1.12
Other   |            | 0.1616     |            |       |  0.14

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

Total # of neighbors = 351132
Ave neighs/atom = 43.891500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.422674385024, Press = 0.28196464746002
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  136000   -36346.964   -36346.964   -36690.383   -36690.383    332.14251    332.14251    160613.39    160613.39   -126.38075   -126.38075 
  137000   -36334.138   -36334.138   -36683.376   -36683.376    337.77048    337.77048    160602.72    160602.72    18.126411    18.126411 
Loop time of 117.713 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.698 hours/ns, 8.495 timesteps/s
100.0% 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.03     | 116.03     | 116.03     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20713    | 0.20713    | 0.20713    |   0.0 |  0.18
Output  | 0.00022612 | 0.00022612 | 0.00022612 |   0.0 |  0.00
Modify  | 1.3171     | 1.3171     | 1.3171     |   0.0 |  1.12
Other   |            | 0.1607     |            |       |  0.14

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

Total # of neighbors = 350732
Ave neighs/atom = 43.841500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.430712165703, Press = 0.355906664860353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  137000   -36334.138   -36334.138   -36683.376   -36683.376    337.77048    337.77048    160602.72    160602.72    18.126411    18.126411 
  138000   -36347.381   -36347.381    -36689.55    -36689.55    330.93318    330.93318    160509.75    160509.75    517.32432    517.32432 
Loop time of 117.585 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.663 hours/ns, 8.504 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.9      | 115.9      | 115.9      |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20831    | 0.20831    | 0.20831    |   0.0 |  0.18
Output  | 0.00022558 | 0.00022558 | 0.00022558 |   0.0 |  0.00
Modify  | 1.3144     | 1.3144     | 1.3144     |   0.0 |  1.12
Other   |            | 0.1607     |            |       |  0.14

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

Total # of neighbors = 350596
Ave neighs/atom = 43.824500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.433649358265, Press = 0.225862008532182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  138000   -36347.381   -36347.381    -36689.55    -36689.55    330.93318    330.93318    160509.75    160509.75    517.32432    517.32432 
  139000   -36353.699   -36353.699   -36697.484   -36697.484    332.49613    332.49613    160753.77    160753.77   -997.55311   -997.55311 
Loop time of 117.703 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.734 ns/day, 32.695 hours/ns, 8.496 timesteps/s
100.0% 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.02     | 116.02     | 116.02     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20646    | 0.20646    | 0.20646    |   0.0 |  0.18
Output  | 0.00022496 | 0.00022496 | 0.00022496 |   0.0 |  0.00
Modify  | 1.3135     | 1.3135     | 1.3135     |   0.0 |  1.12
Other   |            | 0.1605     |            |       |  0.14

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

Total # of neighbors = 351280
Ave neighs/atom = 43.910000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4281204809, Press = 0.255772860528113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  139000   -36353.699   -36353.699   -36697.484   -36697.484    332.49613    332.49613    160753.77    160753.77   -997.55311   -997.55311 
  140000   -36342.791   -36342.791   -36686.565   -36686.565    332.48531    332.48531    160506.42    160506.42     623.5748     623.5748 
Loop time of 120.489 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.717 ns/day, 33.469 hours/ns, 8.300 timesteps/s
100.0% 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 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20788    | 0.20788    | 0.20788    |   0.0 |  0.17
Output  | 0.00038574 | 0.00038574 | 0.00038574 |   0.0 |  0.00
Modify  | 1.3634     | 1.3634     | 1.3634     |   0.0 |  1.13
Other   |            | 0.1632     |            |       |  0.14

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

Total # of neighbors = 350786
Ave neighs/atom = 43.848250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.421110901699, Press = 0.462068481013744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  140000   -36342.791   -36342.791   -36686.565   -36686.565    332.48531    332.48531    160506.42    160506.42     623.5748     623.5748 
  141000   -36352.836   -36352.836   -36691.692   -36691.692    327.72946    327.72946    160564.22    160564.22    119.50188    119.50188 
Loop time of 126.731 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.682 ns/day, 35.203 hours/ns, 7.891 timesteps/s
100.0% 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.88     | 124.88     | 124.88     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21496    | 0.21496    | 0.21496    |   0.0 |  0.17
Output  | 0.0002248  | 0.0002248  | 0.0002248  |   0.0 |  0.00
Modify  | 1.466      | 1.466      | 1.466      |   0.0 |  1.16
Other   |            | 0.1701     |            |       |  0.13

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

Total # of neighbors = 351150
Ave neighs/atom = 43.893750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.406955854963, Press = 0.164983273289385
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  141000   -36352.836   -36352.836   -36691.692   -36691.692    327.72946    327.72946    160564.22    160564.22    119.50188    119.50188 
  142000   -36342.896   -36342.896   -36692.052   -36692.052    337.69049    337.69049    160664.44    160664.44   -390.27397   -390.27397 
Loop time of 117.605 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.668 hours/ns, 8.503 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.93     | 115.93     | 115.93     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20645    | 0.20645    | 0.20645    |   0.0 |  0.18
Output  | 0.00027467 | 0.00027467 | 0.00027467 |   0.0 |  0.00
Modify  | 1.3122     | 1.3122     | 1.3122     |   0.0 |  1.12
Other   |            | 0.16       |            |       |  0.14

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

Total # of neighbors = 350964
Ave neighs/atom = 43.870500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.398614854084, Press = 0.324259178655889
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  142000   -36342.896   -36342.896   -36692.052   -36692.052    337.69049    337.69049    160664.44    160664.44   -390.27397   -390.27397 
  143000   -36338.516   -36338.516   -36683.671   -36683.671    333.82166    333.82166    160568.54    160568.54    237.78687    237.78687 
Loop time of 129.268 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.668 ns/day, 35.908 hours/ns, 7.736 timesteps/s
100.0% 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.38     | 127.38     | 127.38     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21623    | 0.21623    | 0.21623    |   0.0 |  0.17
Output  | 0.00023414 | 0.00023414 | 0.00023414 |   0.0 |  0.00
Modify  | 1.5022     | 1.5022     | 1.5022     |   0.0 |  1.16
Other   |            | 0.1724     |            |       |  0.13

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

Total # of neighbors = 350718
Ave neighs/atom = 43.839750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.392026288916, Press = 0.278993135931518
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  143000   -36338.516   -36338.516   -36683.671   -36683.671    333.82166    333.82166    160568.54    160568.54    237.78687    237.78687 
  144000   -36347.414   -36347.414   -36688.539   -36688.539    329.92411    329.92411    160618.15    160618.15   -100.62054   -100.62054 
Loop time of 133.77 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.646 ns/day, 37.158 hours/ns, 7.476 timesteps/s
100.0% 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 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22267    | 0.22267    | 0.22267    |   0.0 |  0.17
Output  | 0.0003296  | 0.0003296  | 0.0003296  |   0.0 |  0.00
Modify  | 1.588      | 1.588      | 1.588      |   0.0 |  1.19
Other   |            | 0.178      |            |       |  0.13

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

Total # of neighbors = 350690
Ave neighs/atom = 43.836250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.400624005941, Press = 0.269746928958383
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  144000   -36347.414   -36347.414   -36688.539   -36688.539    329.92411    329.92411    160618.15    160618.15   -100.62054   -100.62054 
  145000    -36337.39    -36337.39   -36689.648   -36689.648    340.69145    340.69145    160594.45    160594.45     19.06189     19.06189 
Loop time of 138.792 on 1 procs for 1000 steps with 8000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.72     | 136.72     | 136.72     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22659    | 0.22659    | 0.22659    |   0.0 |  0.16
Output  | 0.00022737 | 0.00022737 | 0.00022737 |   0.0 |  0.00
Modify  | 1.6654     | 1.6654     | 1.6654     |   0.0 |  1.20
Other   |            | 0.1837     |            |       |  0.13

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

Total # of neighbors = 350852
Ave neighs/atom = 43.856500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.407109908658, Press = 0.282753950542923
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  145000    -36337.39    -36337.39   -36689.648   -36689.648    340.69145    340.69145    160594.45    160594.45     19.06189     19.06189 
  146000   -36343.953   -36343.953   -36691.349   -36691.349    335.98847    335.98847    160589.54    160589.54    25.833453    25.833453 
Loop time of 138.711 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.623 ns/day, 38.531 hours/ns, 7.209 timesteps/s
100.0% 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.63     | 136.63     | 136.63     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22604    | 0.22604    | 0.22604    |   0.0 |  0.16
Output  | 0.00027671 | 0.00027671 | 0.00027671 |   0.0 |  0.00
Modify  | 1.6709     | 1.6709     | 1.6709     |   0.0 |  1.20
Other   |            | 0.1834     |            |       |  0.13

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

Total # of neighbors = 350826
Ave neighs/atom = 43.853250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.408213029848, Press = 0.272018670465785
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  146000   -36343.953   -36343.953   -36691.349   -36691.349    335.98847    335.98847    160589.54    160589.54    25.833453    25.833453 
  147000   -36345.879   -36345.879   -36691.726   -36691.726    334.49003    334.49003    160610.81    160610.81   -85.837694   -85.837694 
Loop time of 139.436 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.620 ns/day, 38.732 hours/ns, 7.172 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.35     | 137.35     | 137.35     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2289     | 0.2289     | 0.2289     |   0.0 |  0.16
Output  | 0.00028943 | 0.00028943 | 0.00028943 |   0.0 |  0.00
Modify  | 1.6766     | 1.6766     | 1.6766     |   0.0 |  1.20
Other   |            | 0.1847     |            |       |  0.13

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

Total # of neighbors = 350760
Ave neighs/atom = 43.845000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.406845636711, Press = 0.235580032063666
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  147000   -36345.879   -36345.879   -36691.726   -36691.726    334.49003    334.49003    160610.81    160610.81   -85.837694   -85.837694 
  148000   -36352.703   -36352.703   -36695.009   -36695.009    331.06579    331.06579    160590.95    160590.95   -1.0599484   -1.0599484 
Loop time of 139.51 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.619 ns/day, 38.753 hours/ns, 7.168 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.41     | 137.41     | 137.41     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22717    | 0.22717    | 0.22717    |   0.0 |  0.16
Output  | 0.00022866 | 0.00022866 | 0.00022866 |   0.0 |  0.00
Modify  | 1.6837     | 1.6837     | 1.6837     |   0.0 |  1.21
Other   |            | 0.1849     |            |       |  0.13

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

Total # of neighbors = 350834
Ave neighs/atom = 43.854250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.402678310676, Press = 0.288567860835345
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  148000   -36352.703   -36352.703   -36695.009   -36695.009    331.06579    331.06579    160590.95    160590.95   -1.0599484   -1.0599484 
  149000   -36343.703   -36343.703   -36690.277   -36690.277    335.19264    335.19264    160579.78    160579.78    140.09577    140.09577 
Loop time of 123.745 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.698 ns/day, 34.374 hours/ns, 8.081 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    | 121.95     | 121.95     | 121.95     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2077     | 0.2077     | 0.2077     |   0.0 |  0.17
Output  | 0.00022941 | 0.00022941 | 0.00022941 |   0.0 |  0.00
Modify  | 1.4187     | 1.4187     | 1.4187     |   0.0 |  1.15
Other   |            | 0.1676     |            |       |  0.14

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

Total # of neighbors = 351138
Ave neighs/atom = 43.892250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.395073811155, Press = 0.208854570514204
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  149000   -36343.703   -36343.703   -36690.277   -36690.277    335.19264    335.19264    160579.78    160579.78    140.09577    140.09577 
  150000    -36349.98    -36349.98   -36691.191   -36691.191    330.00652    330.00652    160707.73    160707.73   -670.41187   -670.41187 
Loop time of 117.94 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.761 hours/ns, 8.479 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    | 116.26     | 116.26     | 116.26     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20416    | 0.20416    | 0.20416    |   0.0 |  0.17
Output  | 0.00021966 | 0.00021966 | 0.00021966 |   0.0 |  0.00
Modify  | 1.3159     | 1.3159     | 1.3159     |   0.0 |  1.12
Other   |            | 0.1616     |            |       |  0.14

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

Total # of neighbors = 350950
Ave neighs/atom = 43.868750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.382614888329, Press = 0.277798190709293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  150000    -36349.98    -36349.98   -36691.191   -36691.191    330.00652    330.00652    160707.73    160707.73   -670.41187   -670.41187 
  151000   -36350.215   -36350.215   -36693.615   -36693.615    332.12312    332.12312     160452.9     160452.9    841.49484    841.49484 
Loop time of 126.317 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.684 ns/day, 35.088 hours/ns, 7.917 timesteps/s
100.0% 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.47     | 124.47     | 124.47     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21233    | 0.21233    | 0.21233    |   0.0 |  0.17
Output  | 0.00022675 | 0.00022675 | 0.00022675 |   0.0 |  0.00
Modify  | 1.4628     | 1.4628     | 1.4628     |   0.0 |  1.16
Other   |            | 0.1713     |            |       |  0.14

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

Total # of neighbors = 350660
Ave neighs/atom = 43.832500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.37941091712, Press = 0.392746895575802
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  151000   -36350.215   -36350.215   -36693.615   -36693.615    332.12312    332.12312     160452.9     160452.9    841.49484    841.49484 
  152000   -36343.018   -36343.018   -36689.456   -36689.456    335.06192    335.06192    160617.53    160617.53   -100.79061   -100.79061 
Loop time of 130.841 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.660 ns/day, 36.345 hours/ns, 7.643 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    | 128.92     | 128.92     | 128.92     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21718    | 0.21718    | 0.21718    |   0.0 |  0.17
Output  | 0.00022718 | 0.00022718 | 0.00022718 |   0.0 |  0.00
Modify  | 1.5279     | 1.5279     | 1.5279     |   0.0 |  1.17
Other   |            | 0.1745     |            |       |  0.13

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

Total # of neighbors = 351676
Ave neighs/atom = 43.959500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.382646616995, Press = 0.107565034943717
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  152000   -36343.018   -36343.018   -36689.456   -36689.456    335.06192    335.06192    160617.53    160617.53   -100.79061   -100.79061 
  153000   -36347.809   -36347.809   -36696.617   -36696.617    337.35474    337.35474    160621.98    160621.98   -176.81024   -176.81024 
Loop time of 139.572 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.619 ns/day, 38.770 hours/ns, 7.165 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.48     | 137.48     | 137.48     |   0.0 | 98.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22604    | 0.22604    | 0.22604    |   0.0 |  0.16
Output  | 0.00064519 | 0.00064519 | 0.00064519 |   0.0 |  0.00
Modify  | 1.6772     | 1.6772     | 1.6772     |   0.0 |  1.20
Other   |            | 0.184      |            |       |  0.13

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

Total # of neighbors = 351068
Ave neighs/atom = 43.883500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.384673172299, Press = 0.281006389750523
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  153000   -36347.809   -36347.809   -36696.617   -36696.617    337.35474    337.35474    160621.98    160621.98   -176.81024   -176.81024 
  154000   -36344.492   -36344.492   -36689.847   -36689.847    334.01486    334.01486    160568.89    160568.89    172.49278    172.49278 
Loop time of 117.627 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.674 hours/ns, 8.501 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.95     | 115.95     | 115.95     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2046     | 0.2046     | 0.2046     |   0.0 |  0.17
Output  | 0.00022488 | 0.00022488 | 0.00022488 |   0.0 |  0.00
Modify  | 1.3101     | 1.3101     | 1.3101     |   0.0 |  1.11
Other   |            | 0.1598     |            |       |  0.14

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

Total # of neighbors = 350876
Ave neighs/atom = 43.859500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383205667002, Press = 0.257282537734647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  154000   -36344.492   -36344.492   -36689.847   -36689.847    334.01486    334.01486    160568.89    160568.89    172.49278    172.49278 
  155000   -36352.578   -36352.578    -36691.07    -36691.07    327.37618    327.37618     160566.6     160566.6    149.07077    149.07077 
Loop time of 133.564 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.647 ns/day, 37.101 hours/ns, 7.487 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.59     | 131.59     | 131.59     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22011    | 0.22011    | 0.22011    |   0.0 |  0.16
Output  | 0.00034839 | 0.00034839 | 0.00034839 |   0.0 |  0.00
Modify  | 1.5791     | 1.5791     | 1.5791     |   0.0 |  1.18
Other   |            | 0.1769     |            |       |  0.13

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

Total # of neighbors = 350968
Ave neighs/atom = 43.871000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.372585148205, Press = 0.216471440393051
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  155000   -36352.578   -36352.578    -36691.07    -36691.07    327.37618    327.37618     160566.6     160566.6    149.07077    149.07077 
  156000   -36342.519   -36342.519   -36688.651   -36688.651    334.76606    334.76606    160635.32    160635.32   -249.50165   -249.50165 
Loop time of 117.562 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.735 ns/day, 32.656 hours/ns, 8.506 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.88     | 115.88     | 115.88     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20146    | 0.20146    | 0.20146    |   0.0 |  0.17
Output  | 0.00022404 | 0.00022404 | 0.00022404 |   0.0 |  0.00
Modify  | 1.3159     | 1.3159     | 1.3159     |   0.0 |  1.12
Other   |            | 0.161      |            |       |  0.14

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

Total # of neighbors = 350992
Ave neighs/atom = 43.874000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.368462041351, Press = 0.240169552002378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  156000   -36342.519   -36342.519   -36688.651   -36688.651    334.76606    334.76606    160635.32    160635.32   -249.50165   -249.50165 
  157000   -36347.051   -36347.051    -36691.81    -36691.81     333.4376     333.4376    160557.24    160557.24    251.38219    251.38219 
Loop time of 117.252 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.570 hours/ns, 8.529 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.58     | 115.58     | 115.58     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20082    | 0.20082    | 0.20082    |   0.0 |  0.17
Output  | 0.00027992 | 0.00027992 | 0.00027992 |   0.0 |  0.00
Modify  | 1.3082     | 1.3082     | 1.3082     |   0.0 |  1.12
Other   |            | 0.1613     |            |       |  0.14

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

Total # of neighbors = 350850
Ave neighs/atom = 43.856250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.356989545173, Press = 0.245694378433378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  157000   -36347.051   -36347.051    -36691.81    -36691.81     333.4376     333.4376    160557.24    160557.24    251.38219    251.38219 
  158000   -36350.729   -36350.729   -36693.091   -36693.091    331.12012    331.12012    160593.77    160593.77    59.102528    59.102528 
Loop time of 117.197 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.555 hours/ns, 8.533 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.52     | 115.52     | 115.52     |   0.0 | 98.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20311    | 0.20311    | 0.20311    |   0.0 |  0.17
Output  | 0.0002742  | 0.0002742  | 0.0002742  |   0.0 |  0.00
Modify  | 1.3089     | 1.3089     | 1.3089     |   0.0 |  1.12
Other   |            | 0.1603     |            |       |  0.14

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

Total # of neighbors = 351206
Ave neighs/atom = 43.900750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.353806954878, Press = 0.175420586911685
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  158000   -36350.729   -36350.729   -36693.091   -36693.091    331.12012    331.12012    160593.77    160593.77    59.102528    59.102528 
  159000   -36339.451   -36339.451   -36684.623   -36684.623     333.8377     333.8377    160654.05    160654.05   -281.41809   -281.41809 
Loop time of 117.179 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.737 ns/day, 32.550 hours/ns, 8.534 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.51     | 115.51     | 115.51     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20051    | 0.20051    | 0.20051    |   0.0 |  0.17
Output  | 0.00022331 | 0.00022331 | 0.00022331 |   0.0 |  0.00
Modify  | 1.307      | 1.307      | 1.307      |   0.0 |  1.12
Other   |            | 0.1607     |            |       |  0.14

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

Total # of neighbors = 351192
Ave neighs/atom = 43.899000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.343948562687, Press = 0.279697517592938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  159000   -36339.451   -36339.451   -36684.623   -36684.623     333.8377     333.8377    160654.05    160654.05   -281.41809   -281.41809 
  160000   -36346.226   -36346.226   -36693.004   -36693.004    335.39043    335.39043    160487.65    160487.65    644.29565    644.29565 
Loop time of 117.946 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.733 ns/day, 32.763 hours/ns, 8.478 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    | 116.27     | 116.27     | 116.27     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20201    | 0.20201    | 0.20201    |   0.0 |  0.17
Output  | 0.00027063 | 0.00027063 | 0.00027063 |   0.0 |  0.00
Modify  | 1.3133     | 1.3133     | 1.3133     |   0.0 |  1.11
Other   |            | 0.1613     |            |       |  0.14

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

Total # of neighbors = 350442
Ave neighs/atom = 43.805250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.344939131712, Press = 0.241724341150025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 19 19 19
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.691 | 4.691 | 4.691 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  160000   -36346.226   -36346.226   -36693.004   -36693.004    335.39043    335.39043    160487.65    160487.65    644.29565    644.29565 
  161000   -36340.503   -36340.503   -36687.096   -36687.096    335.21176    335.21176    160679.86    160679.86   -464.72149   -464.72149 
Loop time of 128.188 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.674 ns/day, 35.608 hours/ns, 7.801 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    | 126.31     | 126.31     | 126.31     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21328    | 0.21328    | 0.21328    |   0.0 |  0.17
Output  | 0.00029863 | 0.00029863 | 0.00029863 |   0.0 |  0.00
Modify  | 1.4899     | 1.4899     | 1.4899     |   0.0 |  1.16
Other   |            | 0.1716     |            |       |  0.13

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

Total # of neighbors = 351398
Ave neighs/atom = 43.924750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
160598.857152473

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0