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

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

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

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtV__MO_912978207512_001
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 27848.129123109 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_912978207512_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -10513.917   -10513.917       -10600       -10600       333.15       333.15    27848.129    27848.129    3301.7316    3301.7316 
    1000   -10419.039   -10419.039   -10513.294   -10513.294    364.77647    364.77647    28027.658    28027.658    2348.4054    2348.4054 
Loop time of 168.853 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.904 hours/ns, 5.922 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    | 168.34     | 168.34     | 168.34     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098428   | 0.098428   | 0.098428   |   0.0 |  0.06
Output  | 0.00019646 | 0.00019646 | 0.00019646 |   0.0 |  0.00
Modify  | 0.35314    | 0.35314    | 0.35314    |   0.0 |  0.21
Other   |            | 0.06182    |            |       |  0.04

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

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -10419.039   -10419.039   -10513.294   -10513.294    364.77647    364.77647    28027.658    28027.658    2348.4054    2348.4054 
    2000    -10424.62    -10424.62   -10506.748   -10506.748    317.84267    317.84267    28034.466    28034.466    2071.0491    2071.0491 
Loop time of 179.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.733 hours/ns, 5.585 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    | 178.51     | 178.51     | 178.51     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099605   | 0.099605   | 0.099605   |   0.0 |  0.06
Output  | 0.00019046 | 0.00019046 | 0.00019046 |   0.0 |  0.00
Modify  | 0.36701    | 0.36701    | 0.36701    |   0.0 |  0.20
Other   |            | 0.06315    |            |       |  0.04

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

Total # of neighbors = 135450
Ave neighs/atom = 67.725000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -10424.62    -10424.62   -10506.748   -10506.748    317.84267    317.84267    28034.466    28034.466    2071.0491    2071.0491 
    3000   -10422.723   -10422.723   -10508.993   -10508.993    333.87291    333.87291    28057.549    28057.549    510.34591    510.34591 
Loop time of 179.2 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.482 ns/day, 49.778 hours/ns, 5.580 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    | 178.68     | 178.68     | 178.68     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098915   | 0.098915   | 0.098915   |   0.0 |  0.06
Output  | 0.00023443 | 0.00023443 | 0.00023443 |   0.0 |  0.00
Modify  | 0.35998    | 0.35998    | 0.35998    |   0.0 |  0.20
Other   |            | 0.06215    |            |       |  0.03

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

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

Performance: 0.483 ns/day, 49.708 hours/ns, 5.588 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    | 178.43     | 178.43     | 178.43     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098763   | 0.098763   | 0.098763   |   0.0 |  0.06
Output  | 0.00025328 | 0.00025328 | 0.00025328 |   0.0 |  0.00
Modify  | 0.3623     | 0.3623     | 0.3623     |   0.0 |  0.20
Other   |            | 0.06269    |            |       |  0.04

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

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

Performance: 0.486 ns/day, 49.373 hours/ns, 5.626 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    | 177.22     | 177.22     | 177.22     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099557   | 0.099557   | 0.099557   |   0.0 |  0.06
Output  | 0.00015418 | 0.00015418 | 0.00015418 |   0.0 |  0.00
Modify  | 0.36265    | 0.36265    | 0.36265    |   0.0 |  0.20
Other   |            | 0.06231    |            |       |  0.04

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

Total # of neighbors = 135338
Ave neighs/atom = 67.669000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 330.89698731467, Press = -1278.20838239965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -10421.429   -10421.429   -10509.801   -10509.801    342.00981    342.00981    28089.007    28089.007   -1149.2631   -1149.2631 
    6000   -10422.951   -10422.951   -10507.778   -10507.778    328.29063    328.29063    28126.209    28126.209   -3099.7191   -3099.7191 
Loop time of 177.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.485 ns/day, 49.441 hours/ns, 5.618 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    | 177.45     | 177.45     | 177.45     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099022   | 0.099022   | 0.099022   |   0.0 |  0.06
Output  | 0.00019181 | 0.00019181 | 0.00019181 |   0.0 |  0.00
Modify  | 0.37821    | 0.37821    | 0.37821    |   0.0 |  0.21
Other   |            | 0.06224    |            |       |  0.03

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

Total # of neighbors = 135412
Ave neighs/atom = 67.706000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.199193769561, Press = -113.648003494326
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -10422.951   -10422.951   -10507.778   -10507.778    328.29063    328.29063    28126.209    28126.209   -3099.7191   -3099.7191 
    7000   -10422.239   -10422.239   -10506.024   -10506.024    324.25467    324.25467    28112.668    28112.668    -2003.401    -2003.401 
Loop time of 179.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.975 hours/ns, 5.558 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    | 179.36     | 179.36     | 179.36     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10078    | 0.10078    | 0.10078    |   0.0 |  0.06
Output  | 0.00015261 | 0.00015261 | 0.00015261 |   0.0 |  0.00
Modify  | 0.386      | 0.386      | 0.386      |   0.0 |  0.21
Other   |            | 0.06265    |            |       |  0.03

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

Total # of neighbors = 135514
Ave neighs/atom = 67.757000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.650145077671, Press = -28.6120331880886
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -10422.239   -10422.239   -10506.024   -10506.024    324.25467    324.25467    28112.668    28112.668    -2003.401    -2003.401 
    8000   -10424.797   -10424.797   -10511.919   -10511.919    337.17213    337.17213    28096.039    28096.039   -1554.2333   -1554.2333 
Loop time of 180.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.086 hours/ns, 5.546 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    | 179.76     | 179.76     | 179.76     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10139    | 0.10139    | 0.10139    |   0.0 |  0.06
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.38988    | 0.38988    | 0.38988    |   0.0 |  0.22
Other   |            | 0.06289    |            |       |  0.03

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

Total # of neighbors = 135878
Ave neighs/atom = 67.939000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.024562358377, Press = -6.32373721377551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -10424.797   -10424.797   -10511.919   -10511.919    337.17213    337.17213    28096.039    28096.039   -1554.2333   -1554.2333 
    9000   -10422.388   -10422.388   -10508.621   -10508.621     333.7302     333.7302     28089.31     28089.31   -955.67253   -955.67253 
Loop time of 180.889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.247 hours/ns, 5.528 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    | 180.33     | 180.33     | 180.33     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10088    | 0.10088    | 0.10088    |   0.0 |  0.06
Output  | 0.00015287 | 0.00015287 | 0.00015287 |   0.0 |  0.00
Modify  | 0.39339    | 0.39339    | 0.39339    |   0.0 |  0.22
Other   |            | 0.06313    |            |       |  0.03

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

Total # of neighbors = 135214
Ave neighs/atom = 67.607000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.218607084607, Press = -2.70578325608107
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -10422.388   -10422.388   -10508.621   -10508.621     333.7302     333.7302     28089.31     28089.31   -955.67253   -955.67253 
   10000   -10423.057   -10423.057    -10509.09    -10509.09    332.95862    332.95862     28073.95     28073.95   -6.5569152   -6.5569152 
Loop time of 181.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.476 ns/day, 50.390 hours/ns, 5.513 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    | 180.84     | 180.84     | 180.84     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10191    | 0.10191    | 0.10191    |   0.0 |  0.06
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.39535    | 0.39535    | 0.39535    |   0.0 |  0.22
Other   |            | 0.06382    |            |       |  0.04

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

Total # of neighbors = 135674
Ave neighs/atom = 67.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 = 332.941659696417, Press = -1.04946521870254
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -10423.057   -10423.057    -10509.09    -10509.09    332.95862    332.95862     28073.95     28073.95   -6.5569152   -6.5569152 
   11000   -10421.007   -10421.007   -10507.158   -10507.158    333.41658    333.41658    28057.955    28057.955    879.15938    879.15938 
Loop time of 181.818 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.475 ns/day, 50.505 hours/ns, 5.500 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    | 181.26     | 181.26     | 181.26     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10202    | 0.10202    | 0.10202    |   0.0 |  0.06
Output  | 0.00023158 | 0.00023158 | 0.00023158 |   0.0 |  0.00
Modify  | 0.39559    | 0.39559    | 0.39559    |   0.0 |  0.22
Other   |            | 0.06373    |            |       |  0.04

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

Total # of neighbors = 135602
Ave neighs/atom = 67.801000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.828641844174, Press = 6.80709460696839
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -10421.007   -10421.007   -10507.158   -10507.158    333.41658    333.41658    28057.955    28057.955    879.15938    879.15938 
   12000   -10425.642   -10425.642   -10510.412   -10510.412    328.06794    328.06794    28028.672    28028.672    2062.9458    2062.9458 
Loop time of 182.505 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.473 ns/day, 50.696 hours/ns, 5.479 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    | 181.95     | 181.95     | 181.95     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10161    | 0.10161    | 0.10161    |   0.0 |  0.06
Output  | 0.0001571  | 0.0001571  | 0.0001571  |   0.0 |  0.00
Modify  | 0.39341    | 0.39341    | 0.39341    |   0.0 |  0.22
Other   |            | 0.06315    |            |       |  0.03

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

Total # of neighbors = 135812
Ave neighs/atom = 67.906000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.922792055593, Press = 4.28053080714684
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -10425.642   -10425.642   -10510.412   -10510.412    328.06794    328.06794    28028.672    28028.672    2062.9458    2062.9458 
   13000   -10419.893   -10419.893   -10504.169   -10504.169    326.15979    326.15979    28028.933    28028.933    2683.0363    2683.0363 
Loop time of 180.717 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.199 hours/ns, 5.534 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    | 180.17     | 180.17     | 180.17     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10065    | 0.10065    | 0.10065    |   0.0 |  0.06
Output  | 0.00015641 | 0.00015641 | 0.00015641 |   0.0 |  0.00
Modify  | 0.38689    | 0.38689    | 0.38689    |   0.0 |  0.21
Other   |            | 0.06294    |            |       |  0.03

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

Total # of neighbors = 135806
Ave neighs/atom = 67.903000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.779638312044, Press = 0.261370909053177
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -10419.893   -10419.893   -10504.169   -10504.169    326.15979    326.15979    28028.933    28028.933    2683.0363    2683.0363 
   14000     -10422.6     -10422.6   -10511.009   -10511.009    342.15044    342.15044    28034.021    28034.021    1753.1979    1753.1979 
Loop time of 181.92 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.475 ns/day, 50.533 hours/ns, 5.497 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    | 181.37     | 181.37     | 181.37     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10137    | 0.10137    | 0.10137    |   0.0 |  0.06
Output  | 0.00015641 | 0.00015641 | 0.00015641 |   0.0 |  0.00
Modify  | 0.38882    | 0.38882    | 0.38882    |   0.0 |  0.21
Other   |            | 0.06296    |            |       |  0.03

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

Total # of neighbors = 136334
Ave neighs/atom = 68.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.764592402659, Press = -2.50029958647886
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000     -10422.6     -10422.6   -10511.009   -10511.009    342.15044    342.15044    28034.021    28034.021    1753.1979    1753.1979 
   15000   -10414.833   -10414.833   -10504.459   -10504.459    346.86258    346.86258    28049.386    28049.386    1795.4882    1795.4882 
Loop time of 180.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.054 hours/ns, 5.550 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    | 179.65     | 179.65     | 179.65     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10082    | 0.10082    | 0.10082    |   0.0 |  0.06
Output  | 0.00057346 | 0.00057346 | 0.00057346 |   0.0 |  0.00
Modify  | 0.38458    | 0.38458    | 0.38458    |   0.0 |  0.21
Other   |            | 0.06286    |            |       |  0.03

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

Total # of neighbors = 135688
Ave neighs/atom = 67.844000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.040009771542, Press = -4.60305801986993
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -10414.833   -10414.833   -10504.459   -10504.459    346.86258    346.86258    28049.386    28049.386    1795.4882    1795.4882 
   16000   -10425.395   -10425.395   -10508.436   -10508.436    321.37835    321.37835    28036.634    28036.634    1655.8023    1655.8023 
Loop time of 181.186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.477 ns/day, 50.330 hours/ns, 5.519 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    | 180.63     | 180.63     | 180.63     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10059    | 0.10059    | 0.10059    |   0.0 |  0.06
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.38914    | 0.38914    | 0.38914    |   0.0 |  0.21
Other   |            | 0.06324    |            |       |  0.03

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

Total # of neighbors = 135910
Ave neighs/atom = 67.955000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.317843996433, Press = -5.39887987434677
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -10425.395   -10425.395   -10508.436   -10508.436    321.37835    321.37835    28036.634    28036.634    1655.8023    1655.8023 
   17000     -10421.9     -10421.9   -10506.829   -10506.829    328.68077    328.68077    28056.261    28056.261    783.35806    783.35806 
Loop time of 182.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.474 ns/day, 50.607 hours/ns, 5.489 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    | 181.63     | 181.63     | 181.63     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10125    | 0.10125    | 0.10125    |   0.0 |  0.06
Output  | 0.00015556 | 0.00015556 | 0.00015556 |   0.0 |  0.00
Modify  | 0.38993    | 0.38993    | 0.38993    |   0.0 |  0.21
Other   |            | 0.06295    |            |       |  0.03

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

Total # of neighbors = 136082
Ave neighs/atom = 68.041000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.181907264868, Press = -6.24300802991282
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000     -10421.9     -10421.9   -10506.829   -10506.829    328.68077    328.68077    28056.261    28056.261    783.35806    783.35806 
   18000   -10421.297   -10421.297   -10507.535   -10507.535    333.75085    333.75085    28070.878    28070.878    138.82446    138.82446 
Loop time of 179.853 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.959 hours/ns, 5.560 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    | 179.31     | 179.31     | 179.31     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099894   | 0.099894   | 0.099894   |   0.0 |  0.06
Output  | 0.00015491 | 0.00015491 | 0.00015491 |   0.0 |  0.00
Modify  | 0.38423    | 0.38423    | 0.38423    |   0.0 |  0.21
Other   |            | 0.06294    |            |       |  0.03

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

Total # of neighbors = 136064
Ave neighs/atom = 68.032000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.011852685223, Press = -7.53300570767483
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -10421.297   -10421.297   -10507.535   -10507.535    333.75085    333.75085    28070.878    28070.878    138.82446    138.82446 
   19000   -10425.665   -10425.665   -10510.998   -10510.998    330.24843    330.24843    28091.132    28091.132    -1419.064    -1419.064 
Loop time of 179.202 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.482 ns/day, 49.778 hours/ns, 5.580 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    | 178.65     | 178.65     | 178.65     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10022    | 0.10022    | 0.10022    |   0.0 |  0.06
Output  | 0.00017171 | 0.00017171 | 0.00017171 |   0.0 |  0.00
Modify  | 0.39021    | 0.39021    | 0.39021    |   0.0 |  0.22
Other   |            | 0.0631     |            |       |  0.04

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

Total # of neighbors = 135686
Ave neighs/atom = 67.843000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.009219606502, Press = -9.16769000024065
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -10425.665   -10425.665   -10510.998   -10510.998    330.24843    330.24843    28091.132    28091.132    -1419.064    -1419.064 
   20000    -10425.44    -10425.44   -10508.221   -10508.221    320.37119    320.37119    28104.106    28104.106   -1965.6854   -1965.6854 
Loop time of 180.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.200 hours/ns, 5.533 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    | 180.17     | 180.17     | 180.17     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10095    | 0.10095    | 0.10095    |   0.0 |  0.06
Output  | 0.00015721 | 0.00015721 | 0.00015721 |   0.0 |  0.00
Modify  | 0.38843    | 0.38843    | 0.38843    |   0.0 |  0.21
Other   |            | 0.06295    |            |       |  0.03

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

Total # of neighbors = 135304
Ave neighs/atom = 67.652000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.896535798172, Press = -6.10897104806237
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000    -10425.44    -10425.44   -10508.221   -10508.221    320.37119    320.37119    28104.106    28104.106   -1965.6854   -1965.6854 
   21000   -10420.574   -10420.574   -10506.034   -10506.034      330.739      330.739    28091.215    28091.215   -956.77775   -956.77775 
Loop time of 177.943 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.486 ns/day, 49.429 hours/ns, 5.620 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    | 177.4      | 177.4      | 177.4      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10009    | 0.10009    | 0.10009    |   0.0 |  0.06
Output  | 0.00024763 | 0.00024763 | 0.00024763 |   0.0 |  0.00
Modify  | 0.3826     | 0.3826     | 0.3826     |   0.0 |  0.22
Other   |            | 0.0622     |            |       |  0.03

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

Total # of neighbors = 135528
Ave neighs/atom = 67.764000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.942045850336, Press = -2.89059898144422
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -10420.574   -10420.574   -10506.034   -10506.034      330.739      330.739    28091.215    28091.215   -956.77775   -956.77775 
   22000   -10422.547   -10422.547   -10509.476   -10509.476      336.426      336.426    28081.962    28081.962   -754.82375   -754.82375 
Loop time of 178.14 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.485 ns/day, 49.483 hours/ns, 5.614 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    | 177.6      | 177.6      | 177.6      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099133   | 0.099133   | 0.099133   |   0.0 |  0.06
Output  | 0.0001543  | 0.0001543  | 0.0001543  |   0.0 |  0.00
Modify  | 0.37914    | 0.37914    | 0.37914    |   0.0 |  0.21
Other   |            | 0.06209    |            |       |  0.03

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

Total # of neighbors = 135766
Ave neighs/atom = 67.883000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.182966957682, Press = -2.53671435865556
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -10422.547   -10422.547   -10509.476   -10509.476      336.426      336.426    28081.962    28081.962   -754.82375   -754.82375 
   23000   -10420.046   -10420.046   -10506.967   -10506.967    336.39254    336.39254    28081.476    28081.476   -521.38325   -521.38325 
Loop time of 183.299 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.471 ns/day, 50.916 hours/ns, 5.456 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 182.74     | 182.74     | 182.74     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10213    | 0.10213    | 0.10213    |   0.0 |  0.06
Output  | 0.00019534 | 0.00019534 | 0.00019534 |   0.0 |  0.00
Modify  | 0.39679    | 0.39679    | 0.39679    |   0.0 |  0.22
Other   |            | 0.06332    |            |       |  0.03

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

Total # of neighbors = 135684
Ave neighs/atom = 67.842000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.201914404864, Press = -2.30970595406535
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -10420.046   -10420.046   -10506.967   -10506.967    336.39254    336.39254    28081.476    28081.476   -521.38325   -521.38325 
   24000   -10422.336   -10422.336   -10507.922   -10507.922    331.22531    331.22531    28083.916    28083.916   -639.85038   -639.85038 
Loop time of 181.776 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.475 ns/day, 50.493 hours/ns, 5.501 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    | 181.22     | 181.22     | 181.22     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10149    | 0.10149    | 0.10149    |   0.0 |  0.06
Output  | 0.00024472 | 0.00024472 | 0.00024472 |   0.0 |  0.00
Modify  | 0.38893    | 0.38893    | 0.38893    |   0.0 |  0.21
Other   |            | 0.06304    |            |       |  0.03

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

Total # of neighbors = 135848
Ave neighs/atom = 67.924000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.39200868346, Press = -1.91522935126476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -10422.336   -10422.336   -10507.922   -10507.922    331.22531    331.22531    28083.916    28083.916   -639.85038   -639.85038 
   25000   -10422.016   -10422.016   -10506.831   -10506.831    328.24384    328.24384    28082.958    28082.958   -531.02039   -531.02039 
Loop time of 181.575 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.476 ns/day, 50.437 hours/ns, 5.507 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    | 181.01     | 181.01     | 181.01     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1031     | 0.1031     | 0.1031     |   0.0 |  0.06
Output  | 0.00015344 | 0.00015344 | 0.00015344 |   0.0 |  0.00
Modify  | 0.39647    | 0.39647    | 0.39647    |   0.0 |  0.22
Other   |            | 0.06435    |            |       |  0.04

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

Total # of neighbors = 135550
Ave neighs/atom = 67.775000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.340353590559, Press = -0.913068356498378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -10422.016   -10422.016   -10506.831   -10506.831    328.24384    328.24384    28082.958    28082.958   -531.02039   -531.02039 
   26000   -10421.168   -10421.168   -10506.931   -10506.931    331.91456    331.91456    28076.424    28076.424   -129.51226   -129.51226 
Loop time of 181.408 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.476 ns/day, 50.391 hours/ns, 5.512 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 180.86     | 180.86     | 180.86     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10034    | 0.10034    | 0.10034    |   0.0 |  0.06
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.38783    | 0.38783    | 0.38783    |   0.0 |  0.21
Other   |            | 0.06313    |            |       |  0.03

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

Total # of neighbors = 135690
Ave neighs/atom = 67.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.399734220347, Press = -0.0738491719389593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -10421.168   -10421.168   -10506.931   -10506.931    331.91456    331.91456    28076.424    28076.424   -129.51226   -129.51226 
   27000   -10420.952   -10420.952   -10507.877   -10507.877    336.40779    336.40779    28058.939    28058.939    837.93566    837.93566 
Loop time of 178.543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.484 ns/day, 49.595 hours/ns, 5.601 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    | 178        | 178        | 178        |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099394   | 0.099394   | 0.099394   |   0.0 |  0.06
Output  | 0.00015595 | 0.00015595 | 0.00015595 |   0.0 |  0.00
Modify  | 0.3848     | 0.3848     | 0.3848     |   0.0 |  0.22
Other   |            | 0.06256    |            |       |  0.04

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

Total # of neighbors = 135616
Ave neighs/atom = 67.808000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.339355052745, Press = 1.05162805864986
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -10420.952   -10420.952   -10507.877   -10507.877    336.40779    336.40779    28058.939    28058.939    837.93566    837.93566 
   28000   -10424.209   -10424.209    -10508.49    -10508.49    326.17338    326.17338    28018.864    28018.864    2751.8087    2751.8087 
Loop time of 178.137 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.485 ns/day, 49.482 hours/ns, 5.614 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.59     | 177.59     | 177.59     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10057    | 0.10057    | 0.10057    |   0.0 |  0.06
Output  | 0.00015495 | 0.00015495 | 0.00015495 |   0.0 |  0.00
Modify  | 0.38546    | 0.38546    | 0.38546    |   0.0 |  0.22
Other   |            | 0.06247    |            |       |  0.04

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

Total # of neighbors = 135808
Ave neighs/atom = 67.904000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.398488309509, Press = 1.22992255434217
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -10424.209   -10424.209    -10508.49    -10508.49    326.17338    326.17338    28018.864    28018.864    2751.8087    2751.8087 
   29000   -10418.134   -10418.134   -10507.399   -10507.399    345.46246    345.46246    28041.921    28041.921    1893.9757    1893.9757 
Loop time of 178.52 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.484 ns/day, 49.589 hours/ns, 5.602 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    | 177.98     | 177.98     | 177.98     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099323   | 0.099323   | 0.099323   |   0.0 |  0.06
Output  | 0.00021305 | 0.00021305 | 0.00021305 |   0.0 |  0.00
Modify  | 0.38054    | 0.38054    | 0.38054    |   0.0 |  0.21
Other   |            | 0.06196    |            |       |  0.03

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

Total # of neighbors = 136012
Ave neighs/atom = 68.006000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.510552803346, Press = -1.00854841733898
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -10418.134   -10418.134   -10507.399   -10507.399    345.46246    345.46246    28041.921    28041.921    1893.9757    1893.9757 
   30000   -10423.563   -10423.563   -10510.285   -10510.285    335.62382    335.62382    28051.317    28051.317    968.58495    968.58495 
Loop time of 184.143 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.469 ns/day, 51.151 hours/ns, 5.431 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    | 183.58     | 183.58     | 183.58     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10238    | 0.10238    | 0.10238    |   0.0 |  0.06
Output  | 0.00015387 | 0.00015387 | 0.00015387 |   0.0 |  0.00
Modify  | 0.39756    | 0.39756    | 0.39756    |   0.0 |  0.22
Other   |            | 0.06417    |            |       |  0.03

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

Total # of neighbors = 136074
Ave neighs/atom = 68.037000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.565836871796, Press = -1.7682703623924
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -10423.563   -10423.563   -10510.285   -10510.285    335.62382    335.62382    28051.317    28051.317    968.58495    968.58495 
   31000   -10425.283   -10425.283   -10508.697   -10508.697    322.82108    322.82108    28045.967    28045.967    1382.3835    1382.3835 
Loop time of 179.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.482 ns/day, 49.820 hours/ns, 5.576 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    | 178.81     | 178.81     | 178.81     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10024    | 0.10024    | 0.10024    |   0.0 |  0.06
Output  | 0.00015657 | 0.00015657 | 0.00015657 |   0.0 |  0.00
Modify  | 0.38279    | 0.38279    | 0.38279    |   0.0 |  0.21
Other   |            | 0.06283    |            |       |  0.04

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

Total # of neighbors = 135846
Ave neighs/atom = 67.923000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.619433907916, Press = -2.29514912372753
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -10425.283   -10425.283   -10508.697   -10508.697    322.82108    322.82108    28045.967    28045.967    1382.3835    1382.3835 
   32000   -10421.641   -10421.641   -10507.668   -10507.668     332.9346     332.9346    28048.855    28048.855    1197.3367    1197.3367 
Loop time of 179.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.971 hours/ns, 5.559 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    | 179.35     | 179.35     | 179.35     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0995     | 0.0995     | 0.0995     |   0.0 |  0.06
Output  | 0.00015385 | 0.00015385 | 0.00015385 |   0.0 |  0.00
Modify  | 0.38131    | 0.38131    | 0.38131    |   0.0 |  0.21
Other   |            | 0.06183    |            |       |  0.03

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

Total # of neighbors = 135666
Ave neighs/atom = 67.833000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.525392789013, Press = -3.25119496868133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -10421.641   -10421.641   -10507.668   -10507.668     332.9346     332.9346    28048.855    28048.855    1197.3367    1197.3367 
   33000   -10427.597   -10427.597   -10512.248   -10512.248    327.60746    327.60746    28052.713    28052.713    584.33239    584.33239 
Loop time of 180.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 50.051 hours/ns, 5.550 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    | 179.64     | 179.64     | 179.64     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10006    | 0.10006    | 0.10006    |   0.0 |  0.06
Output  | 0.00020479 | 0.00020479 | 0.00020479 |   0.0 |  0.00
Modify  | 0.38654    | 0.38654    | 0.38654    |   0.0 |  0.21
Other   |            | 0.06292    |            |       |  0.03

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

Total # of neighbors = 136002
Ave neighs/atom = 68.001000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.46744519932, Press = -5.02896905534863
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -10427.597   -10427.597   -10512.248   -10512.248    327.60746    327.60746    28052.713    28052.713    584.33239    584.33239 
   34000   -10421.761   -10421.761   -10508.177   -10508.177    334.43859    334.43859     28086.81     28086.81   -766.09334   -766.09334 
Loop time of 179.3 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.482 ns/day, 49.806 hours/ns, 5.577 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    | 178.75     | 178.75     | 178.75     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10031    | 0.10031    | 0.10031    |   0.0 |  0.06
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.38648    | 0.38648    | 0.38648    |   0.0 |  0.22
Other   |            | 0.06268    |            |       |  0.03

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

Total # of neighbors = 135462
Ave neighs/atom = 67.731000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.37329391175, Press = -4.24149123040911
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -10421.761   -10421.761   -10508.177   -10508.177    334.43859    334.43859     28086.81     28086.81   -766.09334   -766.09334 
   35000   -10426.376   -10426.376   -10511.186   -10511.186    328.22411    328.22411    28079.119    28079.119   -653.82012   -653.82012 
Loop time of 179.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.481 ns/day, 49.864 hours/ns, 5.571 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    | 178.95     | 178.95     | 178.95     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10095    | 0.10095    | 0.10095    |   0.0 |  0.06
Output  | 0.00015534 | 0.00015534 | 0.00015534 |   0.0 |  0.00
Modify  | 0.39282    | 0.39282    | 0.39282    |   0.0 |  0.22
Other   |            | 0.06331    |            |       |  0.04

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

Total # of neighbors = 135518
Ave neighs/atom = 67.759000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.305444859598, Press = -1.99956547374466
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -10426.376   -10426.376   -10511.186   -10511.186    328.22411    328.22411    28079.119    28079.119   -653.82012   -653.82012 
   36000    -10423.16    -10423.16   -10508.966   -10508.966    332.07661    332.07661    28086.527    28086.527   -908.95169   -908.95169 
Loop time of 180.936 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.260 hours/ns, 5.527 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    | 180.38     | 180.38     | 180.38     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10148    | 0.10148    | 0.10148    |   0.0 |  0.06
Output  | 0.00015279 | 0.00015279 | 0.00015279 |   0.0 |  0.00
Modify  | 0.39286    | 0.39286    | 0.39286    |   0.0 |  0.22
Other   |            | 0.06322    |            |       |  0.03

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

Total # of neighbors = 135250
Ave neighs/atom = 67.625000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.330929943952, Press = -1.30917609892697
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -10423.16    -10423.16   -10508.966   -10508.966    332.07661    332.07661    28086.527    28086.527   -908.95169   -908.95169 
   37000     -10425.1     -10425.1   -10510.558   -10510.558    330.73038    330.73038    28090.093    28090.093   -1374.3237   -1374.3237 
Loop time of 176.463 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.490 ns/day, 49.017 hours/ns, 5.667 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    | 175.93     | 175.93     | 175.93     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098447   | 0.098447   | 0.098447   |   0.0 |  0.06
Output  | 0.00015567 | 0.00015567 | 0.00015567 |   0.0 |  0.00
Modify  | 0.37394    | 0.37394    | 0.37394    |   0.0 |  0.21
Other   |            | 0.06194    |            |       |  0.04

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

Total # of neighbors = 135464
Ave neighs/atom = 67.732000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.413493017043, Press = -1.06592154104479
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000     -10425.1     -10425.1   -10510.558   -10510.558    330.73038    330.73038    28090.093    28090.093   -1374.3237   -1374.3237 
   38000   -10417.933   -10417.933   -10506.483   -10506.483    342.69825    342.69825     28116.14     28116.14   -2124.9998   -2124.9998 
Loop time of 179.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.985 hours/ns, 5.557 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    | 179.4      | 179.4      | 179.4      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10043    | 0.10043    | 0.10043    |   0.0 |  0.06
Output  | 0.00015776 | 0.00015776 | 0.00015776 |   0.0 |  0.00
Modify  | 0.38862    | 0.38862    | 0.38862    |   0.0 |  0.22
Other   |            | 0.06333    |            |       |  0.04

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

Total # of neighbors = 135444
Ave neighs/atom = 67.722000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.446501221129, Press = 0.358649771528909
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -10417.933   -10417.933   -10506.483   -10506.483    342.69825    342.69825     28116.14     28116.14   -2124.9998   -2124.9998 
   39000   -10423.411   -10423.411   -10508.341   -10508.341     328.6889     328.6889    28084.057    28084.057   -572.19434   -572.19434 
Loop time of 177.597 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.486 ns/day, 49.332 hours/ns, 5.631 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.05     | 177.05     | 177.05     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10014    | 0.10014    | 0.10014    |   0.0 |  0.06
Output  | 0.0001857  | 0.0001857  | 0.0001857  |   0.0 |  0.00
Modify  | 0.38216    | 0.38216    | 0.38216    |   0.0 |  0.22
Other   |            | 0.06297    |            |       |  0.04

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

Total # of neighbors = 135442
Ave neighs/atom = 67.721000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.532325533433, Press = 1.03330551286991
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -10423.411   -10423.411   -10508.341   -10508.341     328.6889     328.6889    28084.057    28084.057   -572.19434   -572.19434 
   40000   -10418.655   -10418.655   -10509.068   -10509.068    349.90785    349.90785    28067.407    28067.407    236.54274    236.54274 
Loop time of 178.19 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.485 ns/day, 49.497 hours/ns, 5.612 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.64     | 177.64     | 177.64     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099534   | 0.099534   | 0.099534   |   0.0 |  0.06
Output  | 0.00015319 | 0.00015319 | 0.00015319 |   0.0 |  0.00
Modify  | 0.38437    | 0.38437    | 0.38437    |   0.0 |  0.22
Other   |            | 0.06214    |            |       |  0.03

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

Total # of neighbors = 135400
Ave neighs/atom = 67.700000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.546033509495, Press = 0.777225872691017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -10418.655   -10418.655   -10509.068   -10509.068    349.90785    349.90785    28067.407    28067.407    236.54274    236.54274 
   41000    -10423.74    -10423.74    -10512.09    -10512.09    341.92581    341.92581    28054.072    28054.072    537.66821    537.66821 
Loop time of 175.05 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.625 hours/ns, 5.713 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.52     | 174.52     | 174.52     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098017   | 0.098017   | 0.098017   |   0.0 |  0.06
Output  | 0.00045826 | 0.00045826 | 0.00045826 |   0.0 |  0.00
Modify  | 0.37393    | 0.37393    | 0.37393    |   0.0 |  0.21
Other   |            | 0.06182    |            |       |  0.04

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

Total # of neighbors = 135530
Ave neighs/atom = 67.765000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.55088540388, Press = 0.379517493652237
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    -10423.74    -10423.74    -10512.09    -10512.09    341.92581    341.92581    28054.072    28054.072    537.66821    537.66821 
   42000   -10425.209   -10425.209   -10509.073   -10509.073    324.56222    324.56222    28041.927    28041.927    1520.7216    1520.7216 
Loop time of 176.643 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.489 ns/day, 49.068 hours/ns, 5.661 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    | 176.1      | 176.1      | 176.1      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099553   | 0.099553   | 0.099553   |   0.0 |  0.06
Output  | 0.00020588 | 0.00020588 | 0.00020588 |   0.0 |  0.00
Modify  | 0.38057    | 0.38057    | 0.38057    |   0.0 |  0.22
Other   |            | 0.06199    |            |       |  0.04

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

Total # of neighbors = 135606
Ave neighs/atom = 67.803000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.523714461008, Press = -0.226012283379854
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -10425.209   -10425.209   -10509.073   -10509.073    324.56222    324.56222    28041.927    28041.927    1520.7216    1520.7216 
   43000   -10421.801   -10421.801   -10508.203   -10508.203    334.38606    334.38606     28026.45     28026.45    2369.0641    2369.0641 
Loop time of 178.667 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.484 ns/day, 49.630 hours/ns, 5.597 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    | 178.12     | 178.12     | 178.12     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099581   | 0.099581   | 0.099581   |   0.0 |  0.06
Output  | 0.00015775 | 0.00015775 | 0.00015775 |   0.0 |  0.00
Modify  | 0.38075    | 0.38075    | 0.38075    |   0.0 |  0.21
Other   |            | 0.06222    |            |       |  0.03

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

Total # of neighbors = 135890
Ave neighs/atom = 67.945000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.448165513032, Press = -0.575630121458925
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -10421.801   -10421.801   -10508.203   -10508.203    334.38606    334.38606     28026.45     28026.45    2369.0641    2369.0641 
   44000   -10425.152   -10425.152   -10510.681   -10510.681    331.00752    331.00752    27994.587    27994.587    3925.5764    3925.5764 
Loop time of 183.79 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.470 ns/day, 51.053 hours/ns, 5.441 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    | 183.22     | 183.22     | 183.22     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1031     | 0.1031     | 0.1031     |   0.0 |  0.06
Output  | 0.0002147  | 0.0002147  | 0.0002147  |   0.0 |  0.00
Modify  | 0.40422    | 0.40422    | 0.40422    |   0.0 |  0.22
Other   |            | 0.0645     |            |       |  0.04

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

Total # of neighbors = 136200
Ave neighs/atom = 68.100000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.420555357672, Press = -1.43088081892247
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -10425.152   -10425.152   -10510.681   -10510.681    331.00752    331.00752    27994.587    27994.587    3925.5764    3925.5764 
   45000   -10420.785   -10420.785   -10506.871   -10506.871    333.16033    333.16033    28013.973    28013.973    3282.3529    3282.3529 
Loop time of 180.892 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.248 hours/ns, 5.528 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    | 180.34     | 180.34     | 180.34     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10094    | 0.10094    | 0.10094    |   0.0 |  0.06
Output  | 0.00019479 | 0.00019479 | 0.00019479 |   0.0 |  0.00
Modify  | 0.38992    | 0.38992    | 0.38992    |   0.0 |  0.22
Other   |            | 0.06284    |            |       |  0.03

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

Total # of neighbors = 135890
Ave neighs/atom = 67.945000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.419432014598, Press = -2.70786189520975
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -10420.785   -10420.785   -10506.871   -10506.871    333.16033    333.16033    28013.973    28013.973    3282.3529    3282.3529 
   46000   -10423.868   -10423.868   -10511.729   -10511.729    340.03151    340.03151    28051.319    28051.319    661.74971    661.74971 
Loop time of 180.434 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.120 hours/ns, 5.542 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 179.88     | 179.88     | 179.88     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1006     | 0.1006     | 0.1006     |   0.0 |  0.06
Output  | 0.00015731 | 0.00015731 | 0.00015731 |   0.0 |  0.00
Modify  | 0.39114    | 0.39114    | 0.39114    |   0.0 |  0.22
Other   |            | 0.06333    |            |       |  0.04

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

Total # of neighbors = 136158
Ave neighs/atom = 68.079000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.464061877578, Press = -1.81582328696641
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -10423.868   -10423.868   -10511.729   -10511.729    340.03151    340.03151    28051.319    28051.319    661.74971    661.74971 
   47000   -10421.152   -10421.152   -10508.883   -10508.883    339.52883    339.52883     28067.99     28067.99     201.0459     201.0459 
Loop time of 177.603 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.486 ns/day, 49.334 hours/ns, 5.631 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    | 177.06     | 177.06     | 177.06     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098938   | 0.098938   | 0.098938   |   0.0 |  0.06
Output  | 0.00015491 | 0.00015491 | 0.00015491 |   0.0 |  0.00
Modify  | 0.38243    | 0.38243    | 0.38243    |   0.0 |  0.22
Other   |            | 0.06238    |            |       |  0.04

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

Total # of neighbors = 135630
Ave neighs/atom = 67.815000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.453208336665, Press = -1.74477845916484
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -10421.152   -10421.152   -10508.883   -10508.883    339.52883    339.52883     28067.99     28067.99     201.0459     201.0459 
   48000   -10424.175   -10424.175   -10509.985   -10509.985    332.09451    332.09451    28078.562    28078.562   -469.97772   -469.97772 
Loop time of 177.716 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.486 ns/day, 49.365 hours/ns, 5.627 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    | 177.17     | 177.17     | 177.17     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10043    | 0.10043    | 0.10043    |   0.0 |  0.06
Output  | 0.00019873 | 0.00019873 | 0.00019873 |   0.0 |  0.00
Modify  | 0.37836    | 0.37836    | 0.37836    |   0.0 |  0.21
Other   |            | 0.06244    |            |       |  0.04

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

Total # of neighbors = 135652
Ave neighs/atom = 67.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.429186377042, Press = -2.02418545178704
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -10424.175   -10424.175   -10509.985   -10509.985    332.09451    332.09451    28078.562    28078.562   -469.97772   -469.97772 
   49000   -10419.274   -10419.274    -10507.16    -10507.16    340.12926    340.12926    28108.347    28108.347    -1869.813    -1869.813 
Loop time of 178.848 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.680 hours/ns, 5.591 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.3      | 178.3      | 178.3      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10053    | 0.10053    | 0.10053    |   0.0 |  0.06
Output  | 0.00020345 | 0.00020345 | 0.00020345 |   0.0 |  0.00
Modify  | 0.38071    | 0.38071    | 0.38071    |   0.0 |  0.21
Other   |            | 0.06297    |            |       |  0.04

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

Total # of neighbors = 135308
Ave neighs/atom = 67.654000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.379935839324, Press = -2.24413601864398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -10419.274   -10419.274    -10507.16    -10507.16    340.12926    340.12926    28108.347    28108.347    -1869.813    -1869.813 
   50000   -10422.944   -10422.944   -10508.809   -10508.809     332.3047     332.3047    28132.891    28132.891   -3520.8692   -3520.8692 
Loop time of 179.664 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.481 ns/day, 49.907 hours/ns, 5.566 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    | 179.11     | 179.11     | 179.11     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10083    | 0.10083    | 0.10083    |   0.0 |  0.06
Output  | 0.00015505 | 0.00015505 | 0.00015505 |   0.0 |  0.00
Modify  | 0.39013    | 0.39013    | 0.39013    |   0.0 |  0.22
Other   |            | 0.06277    |            |       |  0.03

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

Total # of neighbors = 135462
Ave neighs/atom = 67.731000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.40137043703, Press = -1.61758999973592
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -10422.944   -10422.944   -10508.809   -10508.809     332.3047     332.3047    28132.891    28132.891   -3520.8692   -3520.8692 
   51000   -10418.991   -10418.991   -10507.971   -10507.971    344.36185    344.36185    28118.605    28118.605   -2542.9582   -2542.9582 
Loop time of 176.991 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.164 hours/ns, 5.650 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.45     | 176.45     | 176.45     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099672   | 0.099672   | 0.099672   |   0.0 |  0.06
Output  | 0.00020224 | 0.00020224 | 0.00020224 |   0.0 |  0.00
Modify  | 0.38111    | 0.38111    | 0.38111    |   0.0 |  0.22
Other   |            | 0.06265    |            |       |  0.04

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

Total # of neighbors = 135158
Ave neighs/atom = 67.579000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.472577452148, Press = -0.69466565566731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -10418.991   -10418.991   -10507.971   -10507.971    344.36185    344.36185    28118.605    28118.605   -2542.9582   -2542.9582 
   52000   -10422.134   -10422.134   -10508.323   -10508.323    333.56029    333.56029    28092.128    28092.128   -1204.6611   -1204.6611 
Loop time of 179.483 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.481 ns/day, 49.856 hours/ns, 5.572 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.94     | 178.94     | 178.94     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099271   | 0.099271   | 0.099271   |   0.0 |  0.06
Output  | 0.00024644 | 0.00024644 | 0.00024644 |   0.0 |  0.00
Modify  | 0.38392    | 0.38392    | 0.38392    |   0.0 |  0.21
Other   |            | 0.06276    |            |       |  0.03

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

Total # of neighbors = 135474
Ave neighs/atom = 67.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.475477745506, Press = -0.235646341157684
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -10422.134   -10422.134   -10508.323   -10508.323    333.56029    333.56029    28092.128    28092.128   -1204.6611   -1204.6611 
   53000    -10427.63    -10427.63   -10510.308   -10510.308    319.97389    319.97389    28071.024    28071.024   -411.97084   -411.97084 
Loop time of 178.99 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.719 hours/ns, 5.587 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.44     | 178.44     | 178.44     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099768   | 0.099768   | 0.099768   |   0.0 |  0.06
Output  | 0.00015258 | 0.00015258 | 0.00015258 |   0.0 |  0.00
Modify  | 0.38426    | 0.38426    | 0.38426    |   0.0 |  0.21
Other   |            | 0.06291    |            |       |  0.04

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

Total # of neighbors = 135504
Ave neighs/atom = 67.752000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.456031654227, Press = -0.0649866971883368
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000    -10427.63    -10427.63   -10510.308   -10510.308    319.97389    319.97389    28071.024    28071.024   -411.97084   -411.97084 
   54000   -10422.126   -10422.126   -10509.313   -10509.313    337.41989    337.41989     28064.62     28064.62    207.65059    207.65059 
Loop time of 177.735 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.486 ns/day, 49.371 hours/ns, 5.626 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.19     | 177.19     | 177.19     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098957   | 0.098957   | 0.098957   |   0.0 |  0.06
Output  | 0.00019954 | 0.00019954 | 0.00019954 |   0.0 |  0.00
Modify  | 0.38092    | 0.38092    | 0.38092    |   0.0 |  0.21
Other   |            | 0.06191    |            |       |  0.03

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

Total # of neighbors = 135478
Ave neighs/atom = 67.739000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.389755508226, Press = 0.302214954479423
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -10422.126   -10422.126   -10509.313   -10509.313    337.41989    337.41989     28064.62     28064.62    207.65059    207.65059 
   55000   -10423.436   -10423.436   -10509.467   -10509.467    332.94716    332.94716    28012.324    28012.324    3168.3125    3168.3125 
Loop time of 178.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.647 hours/ns, 5.595 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    | 178.19     | 178.19     | 178.19     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098924   | 0.098924   | 0.098924   |   0.0 |  0.06
Output  | 0.00015549 | 0.00015549 | 0.00015549 |   0.0 |  0.00
Modify  | 0.38161    | 0.38161    | 0.38161    |   0.0 |  0.21
Other   |            | 0.06284    |            |       |  0.04

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

Total # of neighbors = 135656
Ave neighs/atom = 67.828000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.375634742804, Press = 1.27638331531542
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -10423.436   -10423.436   -10509.467   -10509.467    332.94716    332.94716    28012.324    28012.324    3168.3125    3168.3125 
   56000   -10416.893   -10416.893    -10507.93    -10507.93    352.32188    352.32188    28023.585    28023.585    3013.2574    3013.2574 
Loop time of 177.067 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.185 hours/ns, 5.648 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    | 176.53     | 176.53     | 176.53     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099009   | 0.099009   | 0.099009   |   0.0 |  0.06
Output  | 0.00015457 | 0.00015457 | 0.00015457 |   0.0 |  0.00
Modify  | 0.37728    | 0.37728    | 0.37728    |   0.0 |  0.21
Other   |            | 0.06242    |            |       |  0.04

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

Total # of neighbors = 135976
Ave neighs/atom = 67.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.40429779333, Press = 0.181427664153462
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -10416.893   -10416.893    -10507.93    -10507.93    352.32188    352.32188    28023.585    28023.585    3013.2574    3013.2574 
   57000   -10424.994   -10424.994   -10510.723   -10510.723     331.7813     331.7813    28036.244    28036.244     1809.138     1809.138 
Loop time of 175.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.746 hours/ns, 5.699 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.95     | 174.95     | 174.95     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098213   | 0.098213   | 0.098213   |   0.0 |  0.06
Output  | 0.00015809 | 0.00015809 | 0.00015809 |   0.0 |  0.00
Modify  | 0.37405    | 0.37405    | 0.37405    |   0.0 |  0.21
Other   |            | 0.06158    |            |       |  0.04

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

Total # of neighbors = 135896
Ave neighs/atom = 67.948000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.439721283475, Press = -0.493737899829826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -10424.994   -10424.994   -10510.723   -10510.723     331.7813     331.7813    28036.244    28036.244     1809.138     1809.138 
   58000   -10419.909   -10419.909   -10507.034   -10507.034    337.18036    337.18036    28050.403    28050.403    1409.2585    1409.2585 
Loop time of 176.148 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.490 ns/day, 48.930 hours/ns, 5.677 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.61     | 175.61     | 175.61     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099543   | 0.099543   | 0.099543   |   0.0 |  0.06
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.37705    | 0.37705    | 0.37705    |   0.0 |  0.21
Other   |            | 0.06213    |            |       |  0.04

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

Total # of neighbors = 135688
Ave neighs/atom = 67.844000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.459989789635, Press = -0.801993801795456
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -10419.909   -10419.909   -10507.034   -10507.034    337.18036    337.18036    28050.403    28050.403    1409.2585    1409.2585 
   59000   -10424.013   -10424.013   -10508.466   -10508.466    326.84113    326.84113    28048.719    28048.719     1166.623     1166.623 
Loop time of 175.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.692 hours/ns, 5.705 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.76     | 174.76     | 174.76     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097465   | 0.097465   | 0.097465   |   0.0 |  0.06
Output  | 0.00015791 | 0.00015791 | 0.00015791 |   0.0 |  0.00
Modify  | 0.3716     | 0.3716     | 0.3716     |   0.0 |  0.21
Other   |            | 0.06231    |            |       |  0.04

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

Total # of neighbors = 135830
Ave neighs/atom = 67.915000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.490795552119, Press = -1.07465948854091
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -10424.013   -10424.013   -10508.466   -10508.466    326.84113    326.84113    28048.719    28048.719     1166.623     1166.623 
   60000   -10426.205   -10426.205   -10509.421   -10509.421    322.05613    322.05613    28055.709    28055.709    636.79679    636.79679 
Loop time of 180.881 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.245 hours/ns, 5.528 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    | 180.33     | 180.33     | 180.33     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10036    | 0.10036    | 0.10036    |   0.0 |  0.06
Output  | 0.00015566 | 0.00015566 | 0.00015566 |   0.0 |  0.00
Modify  | 0.38844    | 0.38844    | 0.38844    |   0.0 |  0.21
Other   |            | 0.06324    |            |       |  0.03

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

Total # of neighbors = 135704
Ave neighs/atom = 67.852000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.492502882143, Press = -2.62553697220844
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -10426.205   -10426.205   -10509.421   -10509.421    322.05613    322.05613    28055.709    28055.709    636.79679    636.79679 
   61000   -10420.953   -10420.953   -10509.339   -10509.339    342.06343    342.06343    28093.321    28093.321   -1205.1461   -1205.1461 
Loop time of 176.915 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.143 hours/ns, 5.652 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    | 176.38     | 176.38     | 176.38     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098682   | 0.098682   | 0.098682   |   0.0 |  0.06
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.37841    | 0.37841    | 0.37841    |   0.0 |  0.21
Other   |            | 0.06198    |            |       |  0.04

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

Total # of neighbors = 135884
Ave neighs/atom = 67.942000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.458850581314, Press = -1.93187744549109
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -10420.953   -10420.953   -10509.339   -10509.339    342.06343    342.06343    28093.321    28093.321   -1205.1461   -1205.1461 
   62000   -10426.596   -10426.596   -10509.216   -10509.216    319.74837    319.74837    28090.051    28090.051   -1172.8049   -1172.8049 
Loop time of 175.326 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.702 hours/ns, 5.704 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.79     | 174.79     | 174.79     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098621   | 0.098621   | 0.098621   |   0.0 |  0.06
Output  | 0.00015694 | 0.00015694 | 0.00015694 |   0.0 |  0.00
Modify  | 0.37543    | 0.37543    | 0.37543    |   0.0 |  0.21
Other   |            | 0.06213    |            |       |  0.04

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

Total # of neighbors = 135314
Ave neighs/atom = 67.657000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.443350139183, Press = -0.984371361914757
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -10426.596   -10426.596   -10509.216   -10509.216    319.74837    319.74837    28090.051    28090.051   -1172.8049   -1172.8049 
   63000   -10423.054   -10423.054   -10508.583   -10508.583    331.00482    331.00482    28101.674    28101.674   -1704.8347   -1704.8347 
Loop time of 177.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.227 hours/ns, 5.643 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.67     | 176.67     | 176.67     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099448   | 0.099448   | 0.099448   |   0.0 |  0.06
Output  | 0.00015556 | 0.00015556 | 0.00015556 |   0.0 |  0.00
Modify  | 0.38172    | 0.38172    | 0.38172    |   0.0 |  0.22
Other   |            | 0.06216    |            |       |  0.04

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

Total # of neighbors = 135452
Ave neighs/atom = 67.726000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.393028217356, Press = -0.565573607410187
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -10423.054   -10423.054   -10508.583   -10508.583    331.00482    331.00482    28101.674    28101.674   -1704.8347   -1704.8347 
   64000   -10416.732   -10416.732   -10504.067   -10504.067    337.99802    337.99802     28109.26     28109.26   -1514.3371   -1514.3371 
Loop time of 174.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.594 hours/ns, 5.716 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    | 174.4      | 174.4      | 174.4      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098646   | 0.098646   | 0.098646   |   0.0 |  0.06
Output  | 0.00015555 | 0.00015555 | 0.00015555 |   0.0 |  0.00
Modify  | 0.37476    | 0.37476    | 0.37476    |   0.0 |  0.21
Other   |            | 0.06146    |            |       |  0.04

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

Total # of neighbors = 135272
Ave neighs/atom = 67.636000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.440122984417, Press = -0.395904050055103
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -10416.732   -10416.732   -10504.067   -10504.067    337.99802    337.99802     28109.26     28109.26   -1514.3371   -1514.3371 
   65000   -10425.067   -10425.067   -10510.649   -10510.649    331.20925    331.20925    28111.576    28111.576   -2525.2406   -2525.2406 
Loop time of 177.121 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.200 hours/ns, 5.646 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.58     | 176.58     | 176.58     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099757   | 0.099757   | 0.099757   |   0.0 |  0.06
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.38316    | 0.38316    | 0.38316    |   0.0 |  0.22
Other   |            | 0.06224    |            |       |  0.04

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

Total # of neighbors = 135722
Ave neighs/atom = 67.861000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.451649097174, Press = 0.182446226624661
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -10425.067   -10425.067   -10510.649   -10510.649    331.20925    331.20925    28111.576    28111.576   -2525.2406   -2525.2406 
   66000    -10420.37    -10420.37   -10507.761   -10507.761    338.21497    338.21497    28116.872    28116.872    -2429.156    -2429.156 
Loop time of 178.273 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.485 ns/day, 49.520 hours/ns, 5.609 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.73     | 177.73     | 177.73     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099922   | 0.099922   | 0.099922   |   0.0 |  0.06
Output  | 0.00015517 | 0.00015517 | 0.00015517 |   0.0 |  0.00
Modify  | 0.38165    | 0.38165    | 0.38165    |   0.0 |  0.21
Other   |            | 0.06253    |            |       |  0.04

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

Total # of neighbors = 135130
Ave neighs/atom = 67.565000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.453461146593, Press = 1.21553546215498
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000    -10420.37    -10420.37   -10507.761   -10507.761    338.21497    338.21497    28116.872    28116.872    -2429.156    -2429.156 
   67000   -10425.198   -10425.198    -10510.39    -10510.39     329.7034     329.7034    28075.102    28075.102   -416.95931   -416.95931 
Loop time of 177.086 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.191 hours/ns, 5.647 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.54     | 176.54     | 176.54     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099707   | 0.099707   | 0.099707   |   0.0 |  0.06
Output  | 0.0014088  | 0.0014088  | 0.0014088  |   0.0 |  0.00
Modify  | 0.38081    | 0.38081    | 0.38081    |   0.0 |  0.22
Other   |            | 0.06245    |            |       |  0.04

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

Total # of neighbors = 135456
Ave neighs/atom = 67.728000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.466332720048, Press = 0.713287412692582
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -10425.198   -10425.198    -10510.39    -10510.39     329.7034     329.7034    28075.102    28075.102   -416.95931   -416.95931 
   68000   -10419.392   -10419.392   -10508.485   -10508.485    344.79977    344.79977    28064.653    28064.653    499.67041    499.67041 
Loop time of 173.261 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.128 hours/ns, 5.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    | 172.73     | 172.73     | 172.73     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097185   | 0.097185   | 0.097185   |   0.0 |  0.06
Output  | 0.00019276 | 0.00019276 | 0.00019276 |   0.0 |  0.00
Modify  | 0.36651    | 0.36651    | 0.36651    |   0.0 |  0.21
Other   |            | 0.06173    |            |       |  0.04

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

Total # of neighbors = 135412
Ave neighs/atom = 67.706000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.42689208288, Press = 0.424696107667424
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -10419.392   -10419.392   -10508.485   -10508.485    344.79977    344.79977    28064.653    28064.653    499.67041    499.67041 
   69000   -10426.277   -10426.277   -10511.522   -10511.522    329.90408    329.90408     28041.56     28041.56    1224.1176    1224.1176 
Loop time of 180.538 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.150 hours/ns, 5.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    | 179.98     | 179.98     | 179.98     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10031    | 0.10031    | 0.10031    |   0.0 |  0.06
Output  | 0.00016167 | 0.00016167 | 0.00016167 |   0.0 |  0.00
Modify  | 0.38956    | 0.38956    | 0.38956    |   0.0 |  0.22
Other   |            | 0.06396    |            |       |  0.04

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

Total # of neighbors = 135632
Ave neighs/atom = 67.816000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.408450924052, Press = 0.309523465044469
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -10426.277   -10426.277   -10511.522   -10511.522    329.90408    329.90408     28041.56     28041.56    1224.1176    1224.1176 
   70000   -10421.797   -10421.797   -10506.327   -10506.327    327.13927    327.13927    28012.553    28012.553    3386.4039    3386.4039 
Loop time of 172.946 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.040 hours/ns, 5.782 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.42     | 172.42     | 172.42     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096999   | 0.096999   | 0.096999   |   0.0 |  0.06
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.3667     | 0.3667     | 0.3667     |   0.0 |  0.21
Other   |            | 0.06147    |            |       |  0.04

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

Total # of neighbors = 135508
Ave neighs/atom = 67.754000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.352126387701, Press = 0.168477981959523
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -10421.797   -10421.797   -10506.327   -10506.327    327.13927    327.13927    28012.553    28012.553    3386.4039    3386.4039 
   71000    -10425.39    -10425.39   -10511.768   -10511.768    334.29021    334.29021    27976.481    27976.481    4803.3629    4803.3629 
Loop time of 175.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.773 hours/ns, 5.695 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.05     | 175.05     | 175.05     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09736    | 0.09736    | 0.09736    |   0.0 |  0.06
Output  | 0.0001549  | 0.0001549  | 0.0001549  |   0.0 |  0.00
Modify  | 0.3732     | 0.3732     | 0.3732     |   0.0 |  0.21
Other   |            | 0.06185    |            |       |  0.04

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

Total # of neighbors = 136024
Ave neighs/atom = 68.012000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.32805056955, Press = -0.629783727059891
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000    -10425.39    -10425.39   -10511.768   -10511.768    334.29021    334.29021    27976.481    27976.481    4803.3629    4803.3629 
   72000   -10420.824   -10420.824    -10507.49    -10507.49     335.4084     335.4084    28045.486    28045.486    1640.8986    1640.8986 
Loop time of 176.519 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.489 ns/day, 49.033 hours/ns, 5.665 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    | 175.98     | 175.98     | 175.98     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098106   | 0.098106   | 0.098106   |   0.0 |  0.06
Output  | 0.00017337 | 0.00017337 | 0.00017337 |   0.0 |  0.00
Modify  | 0.37532    | 0.37532    | 0.37532    |   0.0 |  0.21
Other   |            | 0.06244    |            |       |  0.04

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

Total # of neighbors = 136190
Ave neighs/atom = 68.095000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.301120653314, Press = -0.554806195250536
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -10420.824   -10420.824    -10507.49    -10507.49     335.4084     335.4084    28045.486    28045.486    1640.8986    1640.8986 
   73000   -10423.621   -10423.621   -10509.905   -10509.905    333.92842    333.92842    28061.825    28061.825    322.03138    322.03138 
Loop time of 177.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.487 ns/day, 49.231 hours/ns, 5.642 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.69     | 176.69     | 176.69     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099983   | 0.099983   | 0.099983   |   0.0 |  0.06
Output  | 0.00015566 | 0.00015566 | 0.00015566 |   0.0 |  0.00
Modify  | 0.38051    | 0.38051    | 0.38051    |   0.0 |  0.21
Other   |            | 0.06225    |            |       |  0.04

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

Total # of neighbors = 135770
Ave neighs/atom = 67.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.288123280803, Press = -0.589616819466736
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -10423.621   -10423.621   -10509.905   -10509.905    333.92842    333.92842    28061.825    28061.825    322.03138    322.03138 
   74000   -10420.239   -10420.239   -10509.763   -10509.763     346.4683     346.4683     28079.58     28079.58   -481.97883   -481.97883 
Loop time of 176.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.911 hours/ns, 5.679 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.54     | 175.54     | 175.54     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099804   | 0.099804   | 0.099804   |   0.0 |  0.06
Output  | 0.0001546  | 0.0001546  | 0.0001546  |   0.0 |  0.00
Modify  | 0.37889    | 0.37889    | 0.37889    |   0.0 |  0.22
Other   |            | 0.06286    |            |       |  0.04

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

Total # of neighbors = 135610
Ave neighs/atom = 67.805000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.329150793447, Press = -0.787212985076996
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -10420.239   -10420.239   -10509.763   -10509.763     346.4683     346.4683     28079.58     28079.58   -481.97883   -481.97883 
   75000   -10424.903   -10424.903   -10508.765   -10508.765    324.55484    324.55484    28092.073    28092.073   -1212.8089   -1212.8089 
Loop time of 176.999 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.166 hours/ns, 5.650 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.46     | 176.46     | 176.46     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098736   | 0.098736   | 0.098736   |   0.0 |  0.06
Output  | 0.00021721 | 0.00021721 | 0.00021721 |   0.0 |  0.00
Modify  | 0.38026    | 0.38026    | 0.38026    |   0.0 |  0.21
Other   |            | 0.06268    |            |       |  0.04

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

Total # of neighbors = 135386
Ave neighs/atom = 67.693000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.321364564888, Press = -1.076454232849
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -10424.903   -10424.903   -10508.765   -10508.765    324.55484    324.55484    28092.073    28092.073   -1212.8089   -1212.8089 
   76000   -10422.941   -10422.941    -10508.45    -10508.45    330.92779    330.92779    28132.082    28132.082   -3281.9894   -3281.9894 
Loop time of 175.556 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.766 hours/ns, 5.696 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.02     | 175.02     | 175.02     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098242   | 0.098242   | 0.098242   |   0.0 |  0.06
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.37552    | 0.37552    | 0.37552    |   0.0 |  0.21
Other   |            | 0.06242    |            |       |  0.04

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

Total # of neighbors = 135374
Ave neighs/atom = 67.687000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.302091969805, Press = -1.21211932565536
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -10422.941   -10422.941    -10508.45    -10508.45    330.92779    330.92779    28132.082    28132.082   -3281.9894   -3281.9894 
   77000   -10422.805   -10422.805   -10507.742   -10507.742    328.71556    328.71556    28099.461    28099.461   -1586.8121   -1586.8121 
Loop time of 176.546 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.489 ns/day, 49.041 hours/ns, 5.664 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176        | 176        | 176        |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099295   | 0.099295   | 0.099295   |   0.0 |  0.06
Output  | 0.00019363 | 0.00019363 | 0.00019363 |   0.0 |  0.00
Modify  | 0.38103    | 0.38103    | 0.38103    |   0.0 |  0.22
Other   |            | 0.06248    |            |       |  0.04

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

Total # of neighbors = 135258
Ave neighs/atom = 67.629000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.259171681848, Press = -0.302866903619603
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -10422.805   -10422.805   -10507.742   -10507.742    328.71556    328.71556    28099.461    28099.461   -1586.8121   -1586.8121 
   78000    -10421.79    -10421.79     -10507.1     -10507.1    330.15866    330.15866    28088.972    28088.972   -867.80078   -867.80078 
Loop time of 175.929 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.869 hours/ns, 5.684 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.39     | 175.39     | 175.39     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098543   | 0.098543   | 0.098543   |   0.0 |  0.06
Output  | 0.00018969 | 0.00018969 | 0.00018969 |   0.0 |  0.00
Modify  | 0.37841    | 0.37841    | 0.37841    |   0.0 |  0.22
Other   |            | 0.06187    |            |       |  0.04

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0