# 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.4419521689414982*${_u_distance}
variable latticeconst_converted equal 3.4419521689414982*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.4419521689415
Lattice spacing in x,y,z = 3.4419522 3.4419522 3.4419522
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (34.419522 34.419522 34.419522)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (34.419522 34.419522 34.419522)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_FuemmelerVita_2023_Li__MO_386038428339_000
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 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  -3711.0711     -3711.0711     -3797.1541     -3797.1541      333.15         333.15         40776.927      40776.927      2254.8751      2254.8751    
      1000  -3619.8434     -3619.8434     -3708.6642     -3708.6642      343.74553      343.74553      42109.616      42109.616      63.986966      63.986966    
Loop time of 126.932 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.259 hours/ns, 7.878 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.78     | 125.78     | 125.78     |   0.0 | 99.09
Neigh   | 0.55743    | 0.55743    | 0.55743    |   0.0 |  0.44
Comm    | 0.1124     | 0.1124     | 0.1124     |   0.0 |  0.09
Output  | 0.00024642 | 0.00024642 | 0.00024642 |   0.0 |  0.00
Modify  | 0.42074    | 0.42074    | 0.42074    |   0.0 |  0.33
Other   |            | 0.06279    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127592 ave      127592 max      127592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127592
Ave neighs/atom = 63.796
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -3619.8434     -3619.8434     -3708.6642     -3708.6642      343.74553      343.74553      42109.616      42109.616      63.986966      63.986966    
      2000  -3624.3494     -3624.3494     -3710.725      -3710.725       334.28261      334.28261      42171.333      42171.333     -214.26472     -214.26472    
Loop time of 122.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.134 hours/ns, 8.138 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.67     | 121.67     | 121.67     |   0.0 | 99.02
Neigh   | 0.61281    | 0.61281    | 0.61281    |   0.0 |  0.50
Comm    | 0.11165    | 0.11165    | 0.11165    |   0.0 |  0.09
Output  | 0.00024518 | 0.00024518 | 0.00024518 |   0.0 |  0.00
Modify  | 0.42286    | 0.42286    | 0.42286    |   0.0 |  0.34
Other   |            | 0.06207    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3720 ave        3720 max        3720 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127326 ave      127326 max      127326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127326
Ave neighs/atom = 63.663
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3624.3494     -3624.3494     -3710.725      -3710.725       334.28261      334.28261      42171.333      42171.333     -214.26472     -214.26472    
      3000  -3619.3291     -3619.3291     -3705.1218     -3705.1218      332.0267       332.0267       42243.887      42243.887     -277.07809     -277.07809    
Loop time of 122.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.704 ns/day, 34.093 hours/ns, 8.148 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.53     | 121.53     | 121.53     |   0.0 | 99.01
Neigh   | 0.61501    | 0.61501    | 0.61501    |   0.0 |  0.50
Comm    | 0.11113    | 0.11113    | 0.11113    |   0.0 |  0.09
Output  | 0.00024744 | 0.00024744 | 0.00024744 |   0.0 |  0.00
Modify  | 0.42119    | 0.42119    | 0.42119    |   0.0 |  0.34
Other   |            | 0.0617     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3714 ave        3714 max        3714 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127394 ave      127394 max      127394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127394
Ave neighs/atom = 63.697
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -3619.3291     -3619.3291     -3705.1218     -3705.1218      332.0267       332.0267       42243.887      42243.887     -277.07809     -277.07809    
      4000  -3624.4111     -3624.4111     -3707.5659     -3707.5659      321.81766      321.81766      42156.411      42156.411     -147.21959     -147.21959    
Loop time of 123.027 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.174 hours/ns, 8.128 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.79     | 121.79     | 121.79     |   0.0 | 98.99
Neigh   | 0.63979    | 0.63979    | 0.63979    |   0.0 |  0.52
Comm    | 0.11239    | 0.11239    | 0.11239    |   0.0 |  0.09
Output  | 0.00021025 | 0.00021025 | 0.00021025 |   0.0 |  0.00
Modify  | 0.42339    | 0.42339    | 0.42339    |   0.0 |  0.34
Other   |            | 0.06126    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3689 ave        3689 max        3689 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127272 ave      127272 max      127272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127272
Ave neighs/atom = 63.636
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -3624.4111     -3624.4111     -3707.5659     -3707.5659      321.81766      321.81766      42156.411      42156.411     -147.21959     -147.21959    
      5000  -3619.1282     -3619.1282     -3705.8639     -3705.8639      335.67616      335.67616      42000.289      42000.289      533.8628       533.8628     
Loop time of 123.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.182 hours/ns, 8.126 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.81     | 121.81     | 121.81     |   0.0 | 98.99
Neigh   | 0.64641    | 0.64641    | 0.64641    |   0.0 |  0.53
Comm    | 0.11148    | 0.11148    | 0.11148    |   0.0 |  0.09
Output  | 0.00017147 | 0.00017147 | 0.00017147 |   0.0 |  0.00
Modify  | 0.42774    | 0.42774    | 0.42774    |   0.0 |  0.35
Other   |            | 0.06199    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3771 ave        3771 max        3771 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128004 ave      128004 max      128004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128004
Ave neighs/atom = 64.002
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.97457236767, Press = 40.1905654663416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3619.1282     -3619.1282     -3705.8639     -3705.8639      335.67616      335.67616      42000.289      42000.289      533.8628       533.8628     
      6000  -3622.3312     -3622.3312     -3706.1846     -3706.1846      324.52166      324.52166      41927.315      41927.315      655.89043      655.89043    
Loop time of 111.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.773 ns/day, 31.064 hours/ns, 8.942 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.71     | 110.71     | 110.71     |   0.0 | 98.99
Neigh   | 0.59874    | 0.59874    | 0.59874    |   0.0 |  0.54
Comm    | 0.10061    | 0.10061    | 0.10061    |   0.0 |  0.09
Output  | 0.00016959 | 0.00016959 | 0.00016959 |   0.0 |  0.00
Modify  | 0.3688     | 0.3688     | 0.3688     |   0.0 |  0.33
Other   |            | 0.05734    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3760 ave        3760 max        3760 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127804 ave      127804 max      127804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127804
Ave neighs/atom = 63.902
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.806179425485, Press = 64.4537908623948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3622.3312     -3622.3312     -3706.1846     -3706.1846      324.52166      324.52166      41927.315      41927.315      655.89043      655.89043    
      7000  -3620.3934     -3620.3934     -3704.6907     -3704.6907      326.23907      326.23907      42215.275      42215.275     -197.77859     -197.77859    
Loop time of 109.965 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.546 hours/ns, 9.094 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.86     | 108.86     | 108.86     |   0.0 | 98.99
Neigh   | 0.59381    | 0.59381    | 0.59381    |   0.0 |  0.54
Comm    | 0.10004    | 0.10004    | 0.10004    |   0.0 |  0.09
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.3564     | 0.3564     | 0.3564     |   0.0 |  0.32
Other   |            | 0.0561     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3782 ave        3782 max        3782 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127476 ave      127476 max      127476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127476
Ave neighs/atom = 63.738
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.577873124191, Press = 32.7432977003188
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3620.3934     -3620.3934     -3704.6907     -3704.6907      326.23907      326.23907      42215.275      42215.275     -197.77859     -197.77859    
      8000  -3622.4138     -3622.4138     -3707.8096     -3707.8096      330.49068      330.49068      42206.361      42206.361     -226.88959     -226.88959    
Loop time of 110.02 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.561 hours/ns, 9.089 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.91     | 108.91     | 108.91     |   0.0 | 99.00
Neigh   | 0.59358    | 0.59358    | 0.59358    |   0.0 |  0.54
Comm    | 0.10068    | 0.10068    | 0.10068    |   0.0 |  0.09
Output  | 0.00017005 | 0.00017005 | 0.00017005 |   0.0 |  0.00
Modify  | 0.35522    | 0.35522    | 0.35522    |   0.0 |  0.32
Other   |            | 0.05604    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3731 ave        3731 max        3731 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127292 ave      127292 max      127292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127292
Ave neighs/atom = 63.646
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.844598889434, Press = 18.3680138278748
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3622.4138     -3622.4138     -3707.8096     -3707.8096      330.49068      330.49068      42206.361      42206.361     -226.88959     -226.88959    
      9000  -3623.3028     -3623.3028     -3707.9578     -3707.9578      327.62346      327.62346      42485.186      42485.186     -1086.9627     -1086.9627    
Loop time of 109.98 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.550 hours/ns, 9.093 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.85     | 108.85     | 108.85     |   0.0 | 98.97
Neigh   | 0.61808    | 0.61808    | 0.61808    |   0.0 |  0.56
Comm    | 0.10044    | 0.10044    | 0.10044    |   0.0 |  0.09
Output  | 0.00016756 | 0.00016756 | 0.00016756 |   0.0 |  0.00
Modify  | 0.35589    | 0.35589    | 0.35589    |   0.0 |  0.32
Other   |            | 0.05597    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3739 ave        3739 max        3739 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126796 ave      126796 max      126796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126796
Ave neighs/atom = 63.398
Neighbor list builds = 25
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.389476593793, Press = 0.410498934133679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3623.3028     -3623.3028     -3707.9578     -3707.9578      327.62346      327.62346      42485.186      42485.186     -1086.9627     -1086.9627    
     10000  -3623.8476     -3623.8476     -3706.6636     -3706.6636      320.50654      320.50654      42126.784      42126.784      13.069769      13.069769    
Loop time of 109.852 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.515 hours/ns, 9.103 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.75     | 108.75     | 108.75     |   0.0 | 98.99
Neigh   | 0.59395    | 0.59395    | 0.59395    |   0.0 |  0.54
Comm    | 0.10003    | 0.10003    | 0.10003    |   0.0 |  0.09
Output  | 0.00017087 | 0.00017087 | 0.00017087 |   0.0 |  0.00
Modify  | 0.35549    | 0.35549    | 0.35549    |   0.0 |  0.32
Other   |            | 0.0562     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3788 ave        3788 max        3788 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127250 ave      127250 max      127250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127250
Ave neighs/atom = 63.625
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.480944670242, Press = -3.11101594717969
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3623.8476     -3623.8476     -3706.6636     -3706.6636      320.50654      320.50654      42126.784      42126.784      13.069769      13.069769    
     11000  -3621.1458     -3621.1458     -3707.2228     -3707.2228      333.12714      333.12714      42035.682      42035.682      331.13221      331.13221    
Loop time of 109.913 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.531 hours/ns, 9.098 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.81     | 108.81     | 108.81     |   0.0 | 98.99
Neigh   | 0.59456    | 0.59456    | 0.59456    |   0.0 |  0.54
Comm    | 0.099454   | 0.099454   | 0.099454   |   0.0 |  0.09
Output  | 0.00016997 | 0.00016997 | 0.00016997 |   0.0 |  0.00
Modify  | 0.35578    | 0.35578    | 0.35578    |   0.0 |  0.32
Other   |            | 0.0563     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3762 ave        3762 max        3762 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127466 ave      127466 max      127466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127466
Ave neighs/atom = 63.733
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.610386938309, Press = 3.21577661976184
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3621.1458     -3621.1458     -3707.2228     -3707.2228      333.12714      333.12714      42035.682      42035.682      331.13221      331.13221    
     12000  -3617.0936     -3617.0936     -3703.7123     -3703.7123      335.22345      335.22345      41958.022      41958.022      708.58197      708.58197    
Loop time of 110.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.567 hours/ns, 9.088 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.93     | 108.93     | 108.93     |   0.0 | 98.99
Neigh   | 0.59474    | 0.59474    | 0.59474    |   0.0 |  0.54
Comm    | 0.099315   | 0.099315   | 0.099315   |   0.0 |  0.09
Output  | 0.00016954 | 0.00016954 | 0.00016954 |   0.0 |  0.00
Modify  | 0.35596    | 0.35596    | 0.35596    |   0.0 |  0.32
Other   |            | 0.05655    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3756 ave        3756 max        3756 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128088 ave      128088 max      128088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128088
Ave neighs/atom = 64.044
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.722532492939, Press = 12.3573759808657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -3617.0936     -3617.0936     -3703.7123     -3703.7123      335.22345      335.22345      41958.022      41958.022      708.58197      708.58197    
     13000  -3622.7805     -3622.7805     -3708.1683     -3708.1683      330.45926      330.45926      42137.879      42137.879     -21.377616     -21.377616    
Loop time of 109.723 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.479 hours/ns, 9.114 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.62     | 108.62     | 108.62     |   0.0 | 98.99
Neigh   | 0.59421    | 0.59421    | 0.59421    |   0.0 |  0.54
Comm    | 0.099053   | 0.099053   | 0.099053   |   0.0 |  0.09
Output  | 0.00016841 | 0.00016841 | 0.00016841 |   0.0 |  0.00
Modify  | 0.35663    | 0.35663    | 0.35663    |   0.0 |  0.33
Other   |            | 0.05614    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3746 ave        3746 max        3746 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127390 ave      127390 max      127390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127390
Ave neighs/atom = 63.695
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.056317849077, Press = 8.42728691300147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -3622.7805     -3622.7805     -3708.1683     -3708.1683      330.45926      330.45926      42137.879      42137.879     -21.377616     -21.377616    
     14000  -3621.1161     -3621.1161     -3705.9883     -3705.9883      328.46405      328.46405      42278.625      42278.625     -416.42862     -416.42862    
Loop time of 109.936 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.538 hours/ns, 9.096 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.83     | 108.83     | 108.83     |   0.0 | 98.99
Neigh   | 0.59345    | 0.59345    | 0.59345    |   0.0 |  0.54
Comm    | 0.099636   | 0.099636   | 0.099636   |   0.0 |  0.09
Output  | 0.00016775 | 0.00016775 | 0.00016775 |   0.0 |  0.00
Modify  | 0.356      | 0.356      | 0.356      |   0.0 |  0.32
Other   |            | 0.05614    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3690 ave        3690 max        3690 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127310 ave      127310 max      127310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127310
Ave neighs/atom = 63.655
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.1030766828, Press = 5.67154523582882
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3621.1161     -3621.1161     -3705.9883     -3705.9883      328.46405      328.46405      42278.625      42278.625     -416.42862     -416.42862    
     15000  -3621.5338     -3621.5338     -3709.1997     -3709.1997      339.27631      339.27631      42155.968      42155.968      20.640915      20.640915    
Loop time of 109.609 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.447 hours/ns, 9.123 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.5      | 108.5      | 108.5      |   0.0 | 98.99
Neigh   | 0.59469    | 0.59469    | 0.59469    |   0.0 |  0.54
Comm    | 0.099389   | 0.099389   | 0.099389   |   0.0 |  0.09
Output  | 0.00020845 | 0.00020845 | 0.00020845 |   0.0 |  0.00
Modify  | 0.35593    | 0.35593    | 0.35593    |   0.0 |  0.32
Other   |            | 0.05716    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3730 ave        3730 max        3730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127186 ave      127186 max      127186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127186
Ave neighs/atom = 63.593
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.425637343308, Press = 1.07004754208097
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -3621.5338     -3621.5338     -3709.1997     -3709.1997      339.27631      339.27631      42155.968      42155.968      20.640915      20.640915    
     16000  -3619.4675     -3619.4675     -3705.1945     -3705.1945      331.77218      331.77218      42000.585      42000.585      406.93935      406.93935    
Loop time of 109.928 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.536 hours/ns, 9.097 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.82     | 108.82     | 108.82     |   0.0 | 99.00
Neigh   | 0.5931     | 0.5931     | 0.5931     |   0.0 |  0.54
Comm    | 0.099244   | 0.099244   | 0.099244   |   0.0 |  0.09
Output  | 0.00016761 | 0.00016761 | 0.00016761 |   0.0 |  0.00
Modify  | 0.35593    | 0.35593    | 0.35593    |   0.0 |  0.32
Other   |            | 0.05628    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3768 ave        3768 max        3768 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128142 ave      128142 max      128142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128142
Ave neighs/atom = 64.071
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.496996459103, Press = 0.995370506774339
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3619.4675     -3619.4675     -3705.1945     -3705.1945      331.77218      331.77218      42000.585      42000.585      406.93935      406.93935    
     17000  -3624.7282     -3624.7282     -3710.8415     -3710.8415      333.26749      333.26749      41777.923      41777.923      979.75092      979.75092    
Loop time of 110.152 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.598 hours/ns, 9.078 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.07     | 109.07     | 109.07     |   0.0 | 99.02
Neigh   | 0.56935    | 0.56935    | 0.56935    |   0.0 |  0.52
Comm    | 0.099596   | 0.099596   | 0.099596   |   0.0 |  0.09
Output  | 0.00016937 | 0.00016937 | 0.00016937 |   0.0 |  0.00
Modify  | 0.35537    | 0.35537    | 0.35537    |   0.0 |  0.32
Other   |            | 0.05609    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3763 ave        3763 max        3763 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128104 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.320857682615, Press = 5.75266498776342
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3624.7282     -3624.7282     -3710.8415     -3710.8415      333.26749      333.26749      41777.923      41777.923      979.75092      979.75092    
     18000  -3620.5772     -3620.5772     -3707.6293     -3707.6293      336.9006       336.9006       42094.293      42094.293      217.72331      217.72331    
Loop time of 110.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.571 hours/ns, 9.086 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.95     | 108.95     | 108.95     |   0.0 | 99.00
Neigh   | 0.59438    | 0.59438    | 0.59438    |   0.0 |  0.54
Comm    | 0.099772   | 0.099772   | 0.099772   |   0.0 |  0.09
Output  | 0.00016836 | 0.00016836 | 0.00016836 |   0.0 |  0.00
Modify  | 0.35516    | 0.35516    | 0.35516    |   0.0 |  0.32
Other   |            | 0.0559     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3770 ave        3770 max        3770 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127646 ave      127646 max      127646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127646
Ave neighs/atom = 63.823
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.264901894005, Press = 6.62925546333947
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3620.5772     -3620.5772     -3707.6293     -3707.6293      336.9006       336.9006       42094.293      42094.293      217.72331      217.72331    
     19000  -3621.9893     -3621.9893     -3708.6291     -3708.6291      335.30492      335.30492      42232.453      42232.453     -298.05397     -298.05397    
Loop time of 109.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.486 hours/ns, 9.112 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.64     | 108.64     | 108.64     |   0.0 | 98.99
Neigh   | 0.59464    | 0.59464    | 0.59464    |   0.0 |  0.54
Comm    | 0.10012    | 0.10012    | 0.10012    |   0.0 |  0.09
Output  | 0.00017234 | 0.00017234 | 0.00017234 |   0.0 |  0.00
Modify  | 0.35568    | 0.35568    | 0.35568    |   0.0 |  0.32
Other   |            | 0.05643    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3744 ave        3744 max        3744 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127224 ave      127224 max      127224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127224
Ave neighs/atom = 63.612
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.323819054725, Press = 4.10331357529709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -3621.9893     -3621.9893     -3708.6291     -3708.6291      335.30492      335.30492      42232.453      42232.453     -298.05397     -298.05397    
     20000  -3619.4946     -3619.4946     -3706.0049     -3706.0049      334.80364      334.80364      42339.417      42339.417     -569.95392     -569.95392    
Loop time of 109.974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.548 hours/ns, 9.093 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.84     | 108.84     | 108.84     |   0.0 | 98.97
Neigh   | 0.61888    | 0.61888    | 0.61888    |   0.0 |  0.56
Comm    | 0.10035    | 0.10035    | 0.10035    |   0.0 |  0.09
Output  | 0.00017131 | 0.00017131 | 0.00017131 |   0.0 |  0.00
Modify  | 0.35563    | 0.35563    | 0.35563    |   0.0 |  0.32
Other   |            | 0.05614    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3785 ave        3785 max        3785 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127008 ave      127008 max      127008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127008
Ave neighs/atom = 63.504
Neighbor list builds = 25
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.350350772731, Press = 2.82681280022871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3619.4946     -3619.4946     -3706.0049     -3706.0049      334.80364      334.80364      42339.417      42339.417     -569.95392     -569.95392    
     21000  -3621.5156     -3621.5156     -3709.4868     -3709.4868      340.45761      340.45761      42120.084      42120.084      87.957493      87.957493    
Loop time of 109.691 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.470 hours/ns, 9.116 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.61     | 108.61     | 108.61     |   0.0 | 99.01
Neigh   | 0.56974    | 0.56974    | 0.56974    |   0.0 |  0.52
Comm    | 0.099807   | 0.099807   | 0.099807   |   0.0 |  0.09
Output  | 0.00016945 | 0.00016945 | 0.00016945 |   0.0 |  0.00
Modify  | 0.35544    | 0.35544    | 0.35544    |   0.0 |  0.32
Other   |            | 0.05614    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3775 ave        3775 max        3775 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127148 ave      127148 max      127148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127148
Ave neighs/atom = 63.574
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.490054867314, Press = -0.274585597575778
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -3621.5156     -3621.5156     -3709.4868     -3709.4868      340.45761      340.45761      42120.084      42120.084      87.957493      87.957493    
     22000  -3617.049      -3617.049      -3707.3102     -3707.3102      349.32039      349.32039      41875.717      41875.717      974.88219      974.88219    
Loop time of 109.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.513 hours/ns, 9.104 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.74     | 108.74     | 108.74     |   0.0 | 98.99
Neigh   | 0.59386    | 0.59386    | 0.59386    |   0.0 |  0.54
Comm    | 0.099615   | 0.099615   | 0.099615   |   0.0 |  0.09
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.35631    | 0.35631    | 0.35631    |   0.0 |  0.32
Other   |            | 0.05599    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3811 ave        3811 max        3811 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127864 ave      127864 max      127864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127864
Ave neighs/atom = 63.932
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.570347134495, Press = 1.64524761115417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3617.049      -3617.049      -3707.3102     -3707.3102      349.32039      349.32039      41875.717      41875.717      974.88219      974.88219    
     23000  -3622.5086     -3622.5086     -3708.0569     -3708.0569      331.08109      331.08109      41986.739      41986.739      332.36375      332.36375    
Loop time of 110.03 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.564 hours/ns, 9.088 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.93     | 108.93     | 108.93     |   0.0 | 99.00
Neigh   | 0.5918     | 0.5918     | 0.5918     |   0.0 |  0.54
Comm    | 0.099909   | 0.099909   | 0.099909   |   0.0 |  0.09
Output  | 0.00017172 | 0.00017172 | 0.00017172 |   0.0 |  0.00
Modify  | 0.3553     | 0.3553     | 0.3553     |   0.0 |  0.32
Other   |            | 0.05588    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3786 ave        3786 max        3786 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128030 ave      128030 max      128030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128030
Ave neighs/atom = 64.015
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.528752621725, Press = 5.68500799879714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3622.5086     -3622.5086     -3708.0569     -3708.0569      331.08109      331.08109      41986.739      41986.739      332.36375      332.36375    
     24000  -3619.0772     -3619.0772     -3706.2873     -3706.2873      337.51191      337.51191      42205.654      42205.654     -149.06787     -149.06787    
Loop time of 109.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.473 hours/ns, 9.115 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.62     | 108.62     | 108.62     |   0.0 | 99.02
Neigh   | 0.56889    | 0.56889    | 0.56889    |   0.0 |  0.52
Comm    | 0.099541   | 0.099541   | 0.099541   |   0.0 |  0.09
Output  | 0.00017028 | 0.00017028 | 0.00017028 |   0.0 |  0.00
Modify  | 0.35533    | 0.35533    | 0.35533    |   0.0 |  0.32
Other   |            | 0.05607    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3735 ave        3735 max        3735 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127328 ave      127328 max      127328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127328
Ave neighs/atom = 63.664
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.629578918157, Press = 3.73416359488123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -3619.0772     -3619.0772     -3706.2873     -3706.2873      337.51191      337.51191      42205.654      42205.654     -149.06787     -149.06787    
     25000  -3622.0975     -3622.0975     -3707.4458     -3707.4458      330.30666      330.30666      42179.313      42179.313     -116.33454     -116.33454    
Loop time of 121.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.739 hours/ns, 8.233 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.21     | 120.21     | 120.21     |   0.0 | 98.97
Neigh   | 0.63931    | 0.63931    | 0.63931    |   0.0 |  0.53
Comm    | 0.11201    | 0.11201    | 0.11201    |   0.0 |  0.09
Output  | 0.00020589 | 0.00020589 | 0.00020589 |   0.0 |  0.00
Modify  | 0.43371    | 0.43371    | 0.43371    |   0.0 |  0.36
Other   |            | 0.06148    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3749 ave        3749 max        3749 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127226 ave      127226 max      127226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127226
Ave neighs/atom = 63.613
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.543355772112, Press = 4.29164414728492
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3622.0975     -3622.0975     -3707.4458     -3707.4458      330.30666      330.30666      42179.313      42179.313     -116.33454     -116.33454    
     26000  -3621.6858     -3621.6858     -3709.279      -3709.279       338.99468      338.99468      42217.005      42217.005     -249.77697     -249.77697    
Loop time of 123.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.282 hours/ns, 8.103 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.15     | 122.15     | 122.15     |   0.0 | 98.97
Neigh   | 0.64127    | 0.64127    | 0.64127    |   0.0 |  0.52
Comm    | 0.11336    | 0.11336    | 0.11336    |   0.0 |  0.09
Output  | 0.00016958 | 0.00016958 | 0.00016958 |   0.0 |  0.00
Modify  | 0.45152    | 0.45152    | 0.45152    |   0.0 |  0.37
Other   |            | 0.0621     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3762 ave        3762 max        3762 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127148 ave      127148 max      127148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127148
Ave neighs/atom = 63.574
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.560213171321, Press = 2.81989595969201
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3621.6858     -3621.6858     -3709.279      -3709.279       338.99468      338.99468      42217.005      42217.005     -249.77697     -249.77697    
     27000  -3618.7003     -3618.7003     -3706.9331     -3706.9331      341.47026      341.47026      42371.583      42371.583     -646.36589     -646.36589    
Loop time of 122.452 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.706 ns/day, 34.015 hours/ns, 8.166 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.19     | 121.19     | 121.19     |   0.0 | 98.97
Neigh   | 0.6414     | 0.6414     | 0.6414     |   0.0 |  0.52
Comm    | 0.11224    | 0.11224    | 0.11224    |   0.0 |  0.09
Output  | 0.00016852 | 0.00016852 | 0.00016852 |   0.0 |  0.00
Modify  | 0.44248    | 0.44248    | 0.44248    |   0.0 |  0.36
Other   |            | 0.06152    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3735 ave        3735 max        3735 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126984 ave      126984 max      126984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126984
Ave neighs/atom = 63.492
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.53224645487, Press = 1.21172029805627
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3618.7003     -3618.7003     -3706.9331     -3706.9331      341.47026      341.47026      42371.583      42371.583     -646.36589     -646.36589    
     28000  -3621.9208     -3621.9208     -3711.3702     -3711.3702      346.17838      346.17838      42074.673      42074.673      171.88831      171.88831    
Loop time of 122.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.116 hours/ns, 8.142 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.55     | 121.55     | 121.55     |   0.0 | 98.97
Neigh   | 0.64071    | 0.64071    | 0.64071    |   0.0 |  0.52
Comm    | 0.11286    | 0.11286    | 0.11286    |   0.0 |  0.09
Output  | 0.00021335 | 0.00021335 | 0.00021335 |   0.0 |  0.00
Modify  | 0.44806    | 0.44806    | 0.44806    |   0.0 |  0.36
Other   |            | 0.06269    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3767 ave        3767 max        3767 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127226 ave      127226 max      127226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127226
Ave neighs/atom = 63.613
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.539777289062, Press = 0.922472167638167
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3621.9208     -3621.9208     -3711.3702     -3711.3702      346.17838      346.17838      42074.673      42074.673      171.88831      171.88831    
     29000  -3621.0266     -3621.0266     -3707.6993     -3707.6993      335.43223      335.43223      42034.897      42034.897      305.8422       305.8422     
Loop time of 121.362 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.712 hours/ns, 8.240 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.11     | 120.11     | 120.11     |   0.0 | 98.97
Neigh   | 0.64234    | 0.64234    | 0.64234    |   0.0 |  0.53
Comm    | 0.1125     | 0.1125     | 0.1125     |   0.0 |  0.09
Output  | 0.00020807 | 0.00020807 | 0.00020807 |   0.0 |  0.00
Modify  | 0.43776    | 0.43776    | 0.43776    |   0.0 |  0.36
Other   |            | 0.06179    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3742 ave        3742 max        3742 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127562 ave      127562 max      127562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127562
Ave neighs/atom = 63.781
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.575683391122, Press = 1.11256871299594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -3621.0266     -3621.0266     -3707.6993     -3707.6993      335.43223      335.43223      42034.897      42034.897      305.8422       305.8422     
     30000  -3622.275      -3622.275      -3708.5359     -3708.5359      333.83886      333.83886      42010.478      42010.478      388.27045      388.27045    
Loop time of 110.229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.619 hours/ns, 9.072 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.11     | 109.11     | 109.11     |   0.0 | 98.99
Neigh   | 0.59968    | 0.59968    | 0.59968    |   0.0 |  0.54
Comm    | 0.09957    | 0.09957    | 0.09957    |   0.0 |  0.09
Output  | 0.00024737 | 0.00024737 | 0.00024737 |   0.0 |  0.00
Modify  | 0.35982    | 0.35982    | 0.35982    |   0.0 |  0.33
Other   |            | 0.05701    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3758 ave        3758 max        3758 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127570 ave      127570 max      127570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127570
Ave neighs/atom = 63.785
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.640501428242, Press = 3.45735148016128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -3622.275      -3622.275      -3708.5359     -3708.5359      333.83886      333.83886      42010.478      42010.478      388.27045      388.27045    
     31000  -3621.8343     -3621.8343     -3708.7967     -3708.7967      336.5537       336.5537       42187.206      42187.206     -290.67227     -290.67227    
Loop time of 123.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.278 hours/ns, 8.104 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.13     | 122.13     | 122.13     |   0.0 | 98.97
Neigh   | 0.64507    | 0.64507    | 0.64507    |   0.0 |  0.52
Comm    | 0.11325    | 0.11325    | 0.11325    |   0.0 |  0.09
Output  | 0.00016906 | 0.00016906 | 0.00016906 |   0.0 |  0.00
Modify  | 0.44816    | 0.44816    | 0.44816    |   0.0 |  0.36
Other   |            | 0.06194    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3748 ave        3748 max        3748 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127410 ave      127410 max      127410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127410
Ave neighs/atom = 63.705
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.588907801725, Press = 3.68349024025104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -3621.8343     -3621.8343     -3708.7967     -3708.7967      336.5537       336.5537       42187.206      42187.206     -290.67227     -290.67227    
     32000  -3622.9026     -3622.9026     -3709.1637     -3709.1637      333.8396       333.8396       42152.85       42152.85      -89.109624     -89.109624    
Loop time of 123.134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.204 hours/ns, 8.121 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.89     | 121.89     | 121.89     |   0.0 | 98.99
Neigh   | 0.61997    | 0.61997    | 0.61997    |   0.0 |  0.50
Comm    | 0.11212    | 0.11212    | 0.11212    |   0.0 |  0.09
Output  | 0.00020852 | 0.00020852 | 0.00020852 |   0.0 |  0.00
Modify  | 0.4484     | 0.4484     | 0.4484     |   0.0 |  0.36
Other   |            | 0.06201    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3772 ave        3772 max        3772 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127354 ave      127354 max      127354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127354
Ave neighs/atom = 63.677
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.61091278104, Press = 1.97975951411229
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -3622.9026     -3622.9026     -3709.1637     -3709.1637      333.8396       333.8396       42152.85       42152.85      -89.109624     -89.109624    
     33000  -3621.0818     -3621.0818     -3707.1012     -3707.1012      332.90403      332.90403      42213.966      42213.966     -247.4987      -247.4987     
Loop time of 123.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.293 hours/ns, 8.100 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.18     | 122.18     | 122.18     |   0.0 | 98.97
Neigh   | 0.64675    | 0.64675    | 0.64675    |   0.0 |  0.52
Comm    | 0.11601    | 0.11601    | 0.11601    |   0.0 |  0.09
Output  | 0.0001699  | 0.0001699  | 0.0001699  |   0.0 |  0.00
Modify  | 0.45179    | 0.45179    | 0.45179    |   0.0 |  0.37
Other   |            | 0.06233    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3708 ave        3708 max        3708 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127188 ave      127188 max      127188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127188
Ave neighs/atom = 63.594
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.488188267155, Press = 2.06328863440992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -3621.0818     -3621.0818     -3707.1012     -3707.1012      332.90403      332.90403      42213.966      42213.966     -247.4987      -247.4987     
     34000  -3622.4319     -3622.4319     -3709.3046     -3709.3046      336.20634      336.20634      42081.341      42081.341      213.04007      213.04007    
Loop time of 123.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.239 hours/ns, 8.113 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.02     | 122.02     | 122.02     |   0.0 | 98.99
Neigh   | 0.61687    | 0.61687    | 0.61687    |   0.0 |  0.50
Comm    | 0.1126     | 0.1126     | 0.1126     |   0.0 |  0.09
Output  | 0.00021167 | 0.00021167 | 0.00021167 |   0.0 |  0.00
Modify  | 0.44801    | 0.44801    | 0.44801    |   0.0 |  0.36
Other   |            | 0.06205    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3736 ave        3736 max        3736 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127502 ave      127502 max      127502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127502
Ave neighs/atom = 63.751
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.437610051, Press = 1.02507379087881
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -3622.4319     -3622.4319     -3709.3046     -3709.3046      336.20634      336.20634      42081.341      42081.341      213.04007      213.04007    
     35000  -3622.243      -3622.243      -3708.8272     -3708.8272      335.08965      335.08965      42017.84       42017.84       352.4929       352.4929     
Loop time of 123.585 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.329 hours/ns, 8.092 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.34     | 122.34     | 122.34     |   0.0 | 98.99
Neigh   | 0.61802    | 0.61802    | 0.61802    |   0.0 |  0.50
Comm    | 0.11279    | 0.11279    | 0.11279    |   0.0 |  0.09
Output  | 0.00017767 | 0.00017767 | 0.00017767 |   0.0 |  0.00
Modify  | 0.44853    | 0.44853    | 0.44853    |   0.0 |  0.36
Other   |            | 0.06271    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3752 ave        3752 max        3752 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127248 ave      127248 max      127248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127248
Ave neighs/atom = 63.624
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.349611634221, Press = 1.98114795072599
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -3622.243      -3622.243      -3708.8272     -3708.8272      335.08965      335.08965      42017.84       42017.84       352.4929       352.4929     
     36000  -3616.3507     -3616.3507     -3705.0901     -3705.0901      343.43069      343.43069      42123.547      42123.547      149.60563      149.60563    
Loop time of 110.117 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.588 hours/ns, 9.081 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.01     | 109.01     | 109.01     |   0.0 | 98.99
Neigh   | 0.59506    | 0.59506    | 0.59506    |   0.0 |  0.54
Comm    | 0.098037   | 0.098037   | 0.098037   |   0.0 |  0.09
Output  | 0.00016944 | 0.00016944 | 0.00016944 |   0.0 |  0.00
Modify  | 0.35838    | 0.35838    | 0.35838    |   0.0 |  0.33
Other   |            | 0.05743    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3766 ave        3766 max        3766 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127988 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.427693238843, Press = 2.7749598613353
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -3616.3507     -3616.3507     -3705.0901     -3705.0901      343.43069      343.43069      42123.547      42123.547      149.60563      149.60563    
     37000  -3622.9511     -3622.9511     -3709.7489     -3709.7489      335.9166       335.9166       42120.523      42120.523     -58.345552     -58.345552    
Loop time of 109.303 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.362 hours/ns, 9.149 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.2      | 108.2      | 108.2      |   0.0 | 98.99
Neigh   | 0.59178    | 0.59178    | 0.59178    |   0.0 |  0.54
Comm    | 0.097824   | 0.097824   | 0.097824   |   0.0 |  0.09
Output  | 0.00016872 | 0.00016872 | 0.00016872 |   0.0 |  0.00
Modify  | 0.35209    | 0.35209    | 0.35209    |   0.0 |  0.32
Other   |            | 0.05734    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3764 ave        3764 max        3764 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127416 ave      127416 max      127416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127416
Ave neighs/atom = 63.708
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.481061159265, Press = 2.40851945692845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -3622.9511     -3622.9511     -3709.7489     -3709.7489      335.9166       335.9166       42120.523      42120.523     -58.345552     -58.345552    
     38000  -3623.8618     -3623.8618     -3707.8306     -3707.8306      324.96762      324.96762      42103.181      42103.181      9.993941       9.993941     
Loop time of 109.519 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.422 hours/ns, 9.131 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.44     | 108.44     | 108.44     |   0.0 | 99.02
Neigh   | 0.56771    | 0.56771    | 0.56771    |   0.0 |  0.52
Comm    | 0.098299   | 0.098299   | 0.098299   |   0.0 |  0.09
Output  | 0.00051382 | 0.00051382 | 0.00051382 |   0.0 |  0.00
Modify  | 0.35277    | 0.35277    | 0.35277    |   0.0 |  0.32
Other   |            | 0.05712    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127526 ave      127526 max      127526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127526
Ave neighs/atom = 63.763
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.459769107042, Press = 2.75583198882717
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -3623.8618     -3623.8618     -3707.8306     -3707.8306      324.96762      324.96762      42103.181      42103.181      9.993941       9.993941     
     39000  -3622.6982     -3622.6982     -3711.0372     -3711.0372      341.88136      341.88136      42189.507      42189.507     -198.65704     -198.65704    
Loop time of 109.315 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.365 hours/ns, 9.148 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.21     | 108.21     | 108.21     |   0.0 | 98.99
Neigh   | 0.5934     | 0.5934     | 0.5934     |   0.0 |  0.54
Comm    | 0.09824    | 0.09824    | 0.09824    |   0.0 |  0.09
Output  | 0.00020621 | 0.00020621 | 0.00020621 |   0.0 |  0.00
Modify  | 0.35141    | 0.35141    | 0.35141    |   0.0 |  0.32
Other   |            | 0.05768    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3743 ave        3743 max        3743 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127220 ave      127220 max      127220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127220
Ave neighs/atom = 63.61
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.488761217186, Press = 2.08600336910241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3622.6982     -3622.6982     -3711.0372     -3711.0372      341.88136      341.88136      42189.507      42189.507     -198.65704     -198.65704    
     40000  -3627.2675     -3627.2675     -3710.7947     -3710.7947      323.25902      323.25902      42184.907      42184.907     -316.26107     -316.26107    
Loop time of 109.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.371 hours/ns, 9.146 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.24     | 108.24     | 108.24     |   0.0 | 98.99
Neigh   | 0.59289    | 0.59289    | 0.59289    |   0.0 |  0.54
Comm    | 0.098249   | 0.098249   | 0.098249   |   0.0 |  0.09
Output  | 0.00016938 | 0.00016938 | 0.00016938 |   0.0 |  0.00
Modify  | 0.35189    | 0.35189    | 0.35189    |   0.0 |  0.32
Other   |            | 0.05699    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3792 ave        3792 max        3792 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127062 ave      127062 max      127062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127062
Ave neighs/atom = 63.531
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.450839696805, Press = 0.525865988228346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -3627.2675     -3627.2675     -3710.7947     -3710.7947      323.25902      323.25902      42184.907      42184.907     -316.26107     -316.26107    
     41000  -3620.3225     -3620.3225     -3708.6326     -3708.6326      341.76944      341.76944      42033.386      42033.386      342.36161      342.36161    
Loop time of 109.772 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.492 hours/ns, 9.110 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.66     | 108.66     | 108.66     |   0.0 | 98.99
Neigh   | 0.59561    | 0.59561    | 0.59561    |   0.0 |  0.54
Comm    | 0.10044    | 0.10044    | 0.10044    |   0.0 |  0.09
Output  | 0.0001705  | 0.0001705  | 0.0001705  |   0.0 |  0.00
Modify  | 0.35802    | 0.35802    | 0.35802    |   0.0 |  0.33
Other   |            | 0.05682    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3760 ave        3760 max        3760 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127760 ave      127760 max      127760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127760
Ave neighs/atom = 63.88
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.464188177211, Press = 1.08327908012797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -3620.3225     -3620.3225     -3708.6326     -3708.6326      341.76944      341.76944      42033.386      42033.386      342.36161      342.36161    
     42000  -3621.6652     -3621.6652     -3708.1926     -3708.1926      334.86993      334.86993      41921.514      41921.514      720.25197      720.25197    
Loop time of 109.79 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.497 hours/ns, 9.108 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.68     | 108.68     | 108.68     |   0.0 | 98.99
Neigh   | 0.59445    | 0.59445    | 0.59445    |   0.0 |  0.54
Comm    | 0.102      | 0.102      | 0.102      |   0.0 |  0.09
Output  | 0.00016969 | 0.00016969 | 0.00016969 |   0.0 |  0.00
Modify  | 0.35967    | 0.35967    | 0.35967    |   0.0 |  0.33
Other   |            | 0.05674    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3773 ave        3773 max        3773 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128020 ave      128020 max      128020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128020
Ave neighs/atom = 64.01
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.504064749422, Press = 1.44360282899331
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -3621.6652     -3621.6652     -3708.1926     -3708.1926      334.86993      334.86993      41921.514      41921.514      720.25197      720.25197    
     43000  -3619.4114     -3619.4114     -3705.841      -3705.841       334.49138      334.49138      42180.494      42180.494     -37.265183     -37.265183    
Loop time of 110.033 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.565 hours/ns, 9.088 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.9      | 108.9      | 108.9      |   0.0 | 98.97
Neigh   | 0.61945    | 0.61945    | 0.61945    |   0.0 |  0.56
Comm    | 0.10171    | 0.10171    | 0.10171    |   0.0 |  0.09
Output  | 0.00021605 | 0.00021605 | 0.00021605 |   0.0 |  0.00
Modify  | 0.35807    | 0.35807    | 0.35807    |   0.0 |  0.33
Other   |            | 0.0569     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3776 ave        3776 max        3776 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127414 ave      127414 max      127414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127414
Ave neighs/atom = 63.707
Neighbor list builds = 25
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.526667316985, Press = 2.58341250891592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -3619.4114     -3619.4114     -3705.841      -3705.841       334.49138      334.49138      42180.494      42180.494     -37.265183     -37.265183    
     44000  -3628.114      -3628.114      -3710.3338     -3710.3338      318.19908      318.19908      42158.935      42158.935     -275.29319     -275.29319    
Loop time of 109.946 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.541 hours/ns, 9.095 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.83     | 108.83     | 108.83     |   0.0 | 98.99
Neigh   | 0.59475    | 0.59475    | 0.59475    |   0.0 |  0.54
Comm    | 0.10166    | 0.10166    | 0.10166    |   0.0 |  0.09
Output  | 0.00016967 | 0.00016967 | 0.00016967 |   0.0 |  0.00
Modify  | 0.35866    | 0.35866    | 0.35866    |   0.0 |  0.33
Other   |            | 0.05701    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3771 ave        3771 max        3771 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127304 ave      127304 max      127304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127304
Ave neighs/atom = 63.652
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.479712740462, Press = 1.82034047049906
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -3628.114      -3628.114      -3710.3338     -3710.3338      318.19908      318.19908      42158.935      42158.935     -275.29319     -275.29319    
     45000  -3623.9551     -3623.9551     -3708.2437     -3708.2437      326.20588      326.20588      42070.239      42070.239      82.929584      82.929584    
Loop time of 109.864 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.518 hours/ns, 9.102 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.75     | 108.75     | 108.75     |   0.0 | 98.99
Neigh   | 0.59606    | 0.59606    | 0.59606    |   0.0 |  0.54
Comm    | 0.10095    | 0.10095    | 0.10095    |   0.0 |  0.09
Output  | 0.00017024 | 0.00017024 | 0.00017024 |   0.0 |  0.00
Modify  | 0.35958    | 0.35958    | 0.35958    |   0.0 |  0.33
Other   |            | 0.05667    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3735 ave        3735 max        3735 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127538 ave      127538 max      127538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127538
Ave neighs/atom = 63.769
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.460853104538, Press = 1.32530686947918
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -3623.9551     -3623.9551     -3708.2437     -3708.2437      326.20588      326.20588      42070.239      42070.239      82.929584      82.929584    
     46000  -3620.0544     -3620.0544     -3706.8867     -3706.8867      336.04967      336.04967      42127.256      42127.256      98.198341      98.198341    
Loop time of 109.762 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.490 hours/ns, 9.111 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.65     | 108.65     | 108.65     |   0.0 | 98.99
Neigh   | 0.59529    | 0.59529    | 0.59529    |   0.0 |  0.54
Comm    | 0.10163    | 0.10163    | 0.10163    |   0.0 |  0.09
Output  | 0.00021717 | 0.00021717 | 0.00021717 |   0.0 |  0.00
Modify  | 0.35988    | 0.35988    | 0.35988    |   0.0 |  0.33
Other   |            | 0.05619    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3786 ave        3786 max        3786 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127232 ave      127232 max      127232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127232
Ave neighs/atom = 63.616
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.506873013427, Press = 0.859522037154663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -3620.0544     -3620.0544     -3706.8867     -3706.8867      336.04967      336.04967      42127.256      42127.256      98.198341      98.198341    
     47000  -3623.273      -3623.273      -3708.0116     -3708.0116      327.94706      327.94706      42061.37       42061.37       179.75362      179.75362    
Loop time of 109.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.533 hours/ns, 9.098 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.81     | 108.81     | 108.81     |   0.0 | 98.99
Neigh   | 0.59461    | 0.59461    | 0.59461    |   0.0 |  0.54
Comm    | 0.10043    | 0.10043    | 0.10043    |   0.0 |  0.09
Output  | 0.00016964 | 0.00016964 | 0.00016964 |   0.0 |  0.00
Modify  | 0.35863    | 0.35863    | 0.35863    |   0.0 |  0.33
Other   |            | 0.05658    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3731 ave        3731 max        3731 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127652 ave      127652 max      127652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127652
Ave neighs/atom = 63.826
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.541386495789, Press = 1.51280986717585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -3623.273      -3623.273      -3708.0116     -3708.0116      327.94706      327.94706      42061.37       42061.37       179.75362      179.75362    
     48000  -3620.3253     -3620.3253     -3705.5475     -3705.5475      329.81883      329.81883      42368.374      42368.374     -764.08227     -764.08227    
Loop time of 117.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.738 ns/day, 32.538 hours/ns, 8.537 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.94     | 115.94     | 115.94     |   0.0 | 98.98
Neigh   | 0.62013    | 0.62013    | 0.62013    |   0.0 |  0.53
Comm    | 0.10734    | 0.10734    | 0.10734    |   0.0 |  0.09
Output  | 0.00016755 | 0.00016755 | 0.00016755 |   0.0 |  0.00
Modify  | 0.40776    | 0.40776    | 0.40776    |   0.0 |  0.35
Other   |            | 0.06011    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3769 ave        3769 max        3769 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127370 ave      127370 max      127370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127370
Ave neighs/atom = 63.685
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.498645042852, Press = 1.53297439636446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -3620.3253     -3620.3253     -3705.5475     -3705.5475      329.81883      329.81883      42368.374      42368.374     -764.08227     -764.08227    
     49000  -3621.0942     -3621.0942     -3709.2446     -3709.2446      341.15132      341.15132      42264.148      42264.148     -388.84413     -388.84413    
Loop time of 119.576 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.35     | 118.35     | 118.35     |   0.0 | 98.98
Neigh   | 0.62824    | 0.62824    | 0.62824    |   0.0 |  0.53
Comm    | 0.10993    | 0.10993    | 0.10993    |   0.0 |  0.09
Output  | 0.00020635 | 0.00020635 | 0.00020635 |   0.0 |  0.00
Modify  | 0.42524    | 0.42524    | 0.42524    |   0.0 |  0.36
Other   |            | 0.06164    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3734 ave        3734 max        3734 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127082 ave      127082 max      127082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127082
Ave neighs/atom = 63.541
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.556742325474, Press = 0.222347652192732
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -3621.0942     -3621.0942     -3709.2446     -3709.2446      341.15132      341.15132      42264.148      42264.148     -388.84413     -388.84413    
     50000  -3621.7868     -3621.7868     -3706.905      -3706.905       329.41614      329.41614      42138.361      42138.361     -62.235634     -62.235634    
Loop time of 122.942 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.151 hours/ns, 8.134 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.7      | 121.7      | 121.7      |   0.0 | 98.99
Neigh   | 0.6134     | 0.6134     | 0.6134     |   0.0 |  0.50
Comm    | 0.11304    | 0.11304    | 0.11304    |   0.0 |  0.09
Output  | 0.00016794 | 0.00016794 | 0.00016794 |   0.0 |  0.00
Modify  | 0.44826    | 0.44826    | 0.44826    |   0.0 |  0.36
Other   |            | 0.06269    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3730 ave        3730 max        3730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127506 ave      127506 max      127506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127506
Ave neighs/atom = 63.753
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.522724242754, Press = 0.691096594072872
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -3621.7868     -3621.7868     -3706.905      -3706.905       329.41614      329.41614      42138.361      42138.361     -62.235634     -62.235634    
     51000  -3621.2706     -3621.2706     -3706.7593     -3706.7593      330.85         330.85         42215.358      42215.358     -189.28124     -189.28124    
Loop time of 116.757 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.740 ns/day, 32.432 hours/ns, 8.565 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.57     | 115.57     | 115.57     |   0.0 | 98.98
Neigh   | 0.61752    | 0.61752    | 0.61752    |   0.0 |  0.53
Comm    | 0.10787    | 0.10787    | 0.10787    |   0.0 |  0.09
Output  | 0.00020676 | 0.00020676 | 0.00020676 |   0.0 |  0.00
Modify  | 0.40372    | 0.40372    | 0.40372    |   0.0 |  0.35
Other   |            | 0.05931    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3779 ave        3779 max        3779 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127236 ave      127236 max      127236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127236
Ave neighs/atom = 63.618
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.481752839517, Press = 0.404255662465264
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -3621.2706     -3621.2706     -3706.7593     -3706.7593      330.85         330.85         42215.358      42215.358     -189.28124     -189.28124    
     52000  -3618.7049     -3618.7049     -3706.755      -3706.755       340.76316      340.76316      42054.497      42054.497      339.17837      339.17837    
Loop time of 114.157 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.710 hours/ns, 8.760 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    | 113.02     | 113.02     | 113.02     |   0.0 | 99.00
Neigh   | 0.58614    | 0.58614    | 0.58614    |   0.0 |  0.51
Comm    | 0.10502    | 0.10502    | 0.10502    |   0.0 |  0.09
Output  | 0.00020843 | 0.00020843 | 0.00020843 |   0.0 |  0.00
Modify  | 0.38806    | 0.38806    | 0.38806    |   0.0 |  0.34
Other   |            | 0.05799    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3785 ave        3785 max        3785 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127418 ave      127418 max      127418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127418
Ave neighs/atom = 63.709
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.430699376903, Press = 0.703493661744858
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -3618.7049     -3618.7049     -3706.755      -3706.755       340.76316      340.76316      42054.497      42054.497      339.17837      339.17837    
     53000  -3623.1182     -3623.1182     -3708.6897     -3708.6897      331.17055      331.17055      41918.808      41918.808      586.96692      586.96692    
Loop time of 109.357 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.377 hours/ns, 9.144 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.25     | 108.25     | 108.25     |   0.0 | 98.99
Neigh   | 0.59174    | 0.59174    | 0.59174    |   0.0 |  0.54
Comm    | 0.098879   | 0.098879   | 0.098879   |   0.0 |  0.09
Output  | 0.00016821 | 0.00016821 | 0.00016821 |   0.0 |  0.00
Modify  | 0.35521    | 0.35521    | 0.35521    |   0.0 |  0.32
Other   |            | 0.0569     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3793 ave        3793 max        3793 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127730 ave      127730 max      127730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127730
Ave neighs/atom = 63.865
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.484827722403, Press = 1.90991953711981
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -3623.1182     -3623.1182     -3708.6897     -3708.6897      331.17055      331.17055      41918.808      41918.808      586.96692      586.96692    
     54000  -3619.53       -3619.53       -3706.4101     -3706.4101      336.23475      336.23475      42140.264      42140.264      76.123018      76.123018    
Loop time of 115.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.745 ns/day, 32.210 hours/ns, 8.624 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.77     | 114.77     | 114.77     |   0.0 | 98.98
Neigh   | 0.61314    | 0.61314    | 0.61314    |   0.0 |  0.53
Comm    | 0.10722    | 0.10722    | 0.10722    |   0.0 |  0.09
Output  | 0.00020341 | 0.00020341 | 0.00020341 |   0.0 |  0.00
Modify  | 0.40173    | 0.40173    | 0.40173    |   0.0 |  0.35
Other   |            | 0.05839    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3754 ave        3754 max        3754 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127764 ave      127764 max      127764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127764
Ave neighs/atom = 63.882
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.494916065761, Press = 1.96894560134333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -3619.53       -3619.53       -3706.4101     -3706.4101      336.23475      336.23475      42140.264      42140.264      76.123018      76.123018    
     55000  -3624.2858     -3624.2858     -3710.8881     -3710.8881      335.15984      335.15984      42141.548      42141.548     -165.1869      -165.1869     
Loop time of 123.431 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.286 hours/ns, 8.102 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.16     | 122.16     | 122.16     |   0.0 | 98.97
Neigh   | 0.64256    | 0.64256    | 0.64256    |   0.0 |  0.52
Comm    | 0.11524    | 0.11524    | 0.11524    |   0.0 |  0.09
Output  | 0.00016931 | 0.00016931 | 0.00016931 |   0.0 |  0.00
Modify  | 0.44996    | 0.44996    | 0.44996    |   0.0 |  0.36
Other   |            | 0.0622     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3749 ave        3749 max        3749 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127420 ave      127420 max      127420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127420
Ave neighs/atom = 63.71
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.475204817446, Press = 1.54354011260678
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -3624.2858     -3624.2858     -3710.8881     -3710.8881      335.15984      335.15984      42141.548      42141.548     -165.1869      -165.1869     
     56000  -3622.1815     -3622.1815     -3710.1495     -3710.1495      340.44537      340.44537      42243.147      42243.147     -510.63446     -510.63446    
Loop time of 123.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.310 hours/ns, 8.096 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.24     | 122.24     | 122.24     |   0.0 | 98.97
Neigh   | 0.64951    | 0.64951    | 0.64951    |   0.0 |  0.53
Comm    | 0.11457    | 0.11457    | 0.11457    |   0.0 |  0.09
Output  | 0.00020572 | 0.00020572 | 0.00020572 |   0.0 |  0.00
Modify  | 0.45077    | 0.45077    | 0.45077    |   0.0 |  0.36
Other   |            | 0.06205    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3740 ave        3740 max        3740 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127384 ave      127384 max      127384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127384
Ave neighs/atom = 63.692
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.453932717043, Press = 0.821363301482379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -3622.1815     -3622.1815     -3710.1495     -3710.1495      340.44537      340.44537      42243.147      42243.147     -510.63446     -510.63446    
     57000  -3622.6448     -3622.6448     -3708.1678     -3708.1678      330.9831       330.9831       42156.188      42156.188     -83.903692     -83.903692    
Loop time of 123.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.333 hours/ns, 8.091 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.36     | 122.36     | 122.36     |   0.0 | 99.00
Neigh   | 0.61607    | 0.61607    | 0.61607    |   0.0 |  0.50
Comm    | 0.11307    | 0.11307    | 0.11307    |   0.0 |  0.09
Output  | 0.00016999 | 0.00016999 | 0.00016999 |   0.0 |  0.00
Modify  | 0.44899    | 0.44899    | 0.44899    |   0.0 |  0.36
Other   |            | 0.06258    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3780 ave        3780 max        3780 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127196 ave      127196 max      127196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127196
Ave neighs/atom = 63.598
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.383283369956, Press = 0.721698371191213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -3622.6448     -3622.6448     -3708.1678     -3708.1678      330.9831       330.9831       42156.188      42156.188     -83.903692     -83.903692    
     58000  -3621.2326     -3621.2326     -3706.0846     -3706.0846      328.38609      328.38609      42103.163      42103.163      175.01741      175.01741    
Loop time of 123.499 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.305 hours/ns, 8.097 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.22     | 122.22     | 122.22     |   0.0 | 98.97
Neigh   | 0.64506    | 0.64506    | 0.64506    |   0.0 |  0.52
Comm    | 0.11469    | 0.11469    | 0.11469    |   0.0 |  0.09
Output  | 0.00024957 | 0.00024957 | 0.00024957 |   0.0 |  0.00
Modify  | 0.454      | 0.454      | 0.454      |   0.0 |  0.37
Other   |            | 0.0627     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3770 ave        3770 max        3770 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127656 ave      127656 max      127656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127656
Ave neighs/atom = 63.828
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.391881061277, Press = 0.723398495149122
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -3621.2326     -3621.2326     -3706.0846     -3706.0846      328.38609      328.38609      42103.163      42103.163      175.01741      175.01741    
     59000  -3618.6126     -3618.6126     -3707.9412     -3707.9412      345.71078      345.71078      42217.124      42217.124     -204.63012     -204.63012    
Loop time of 112.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.770 ns/day, 31.172 hours/ns, 8.911 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.07     | 111.07     | 111.07     |   0.0 | 98.97
Neigh   | 0.60866    | 0.60866    | 0.60866    |   0.0 |  0.54
Comm    | 0.10647    | 0.10647    | 0.10647    |   0.0 |  0.09
Output  | 0.00024013 | 0.00024013 | 0.00024013 |   0.0 |  0.00
Modify  | 0.37722    | 0.37722    | 0.37722    |   0.0 |  0.34
Other   |            | 0.05786    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3738 ave        3738 max        3738 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127180 ave      127180 max      127180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127180
Ave neighs/atom = 63.59
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.399069868015, Press = 1.1297412707803
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -3618.6126     -3618.6126     -3707.9412     -3707.9412      345.71078      345.71078      42217.124      42217.124     -204.63012     -204.63012    
     60000  -3622.3648     -3622.3648     -3707.7887     -3707.7887      330.59913      330.59913      42207.552      42207.552     -256.40604     -256.40604    
Loop time of 120.145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.719 ns/day, 33.374 hours/ns, 8.323 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.9      | 118.9      | 118.9      |   0.0 | 98.97
Neigh   | 0.63682    | 0.63682    | 0.63682    |   0.0 |  0.53
Comm    | 0.11416    | 0.11416    | 0.11416    |   0.0 |  0.10
Output  | 0.00017137 | 0.00017137 | 0.00017137 |   0.0 |  0.00
Modify  | 0.43041    | 0.43041    | 0.43041    |   0.0 |  0.36
Other   |            | 0.06055    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3774 ave        3774 max        3774 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127462 ave      127462 max      127462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127462
Ave neighs/atom = 63.731
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.422590584197, Press = 1.07300889737525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -3622.3648     -3622.3648     -3707.7887     -3707.7887      330.59913      330.59913      42207.552      42207.552     -256.40604     -256.40604    
     61000  -3622.6061     -3622.6061     -3708.315      -3708.315       331.70223      331.70223      42296.473      42296.473     -472.48245     -472.48245    
Loop time of 121.5 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.750 hours/ns, 8.230 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.27     | 120.27     | 120.27     |   0.0 | 98.99
Neigh   | 0.61739    | 0.61739    | 0.61739    |   0.0 |  0.51
Comm    | 0.11432    | 0.11432    | 0.11432    |   0.0 |  0.09
Output  | 0.00020521 | 0.00020521 | 0.00020521 |   0.0 |  0.00
Modify  | 0.43975    | 0.43975    | 0.43975    |   0.0 |  0.36
Other   |            | 0.06127    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3753 ave        3753 max        3753 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126848 ave      126848 max      126848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126848
Ave neighs/atom = 63.424
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.427923060694, Press = 0.0810806087739121
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -3622.6061     -3622.6061     -3708.315      -3708.315       331.70223      331.70223      42296.473      42296.473     -472.48245     -472.48245    
     62000  -3618.9332     -3618.9332     -3705.1562     -3705.1562      333.69188      333.69188      42180.781      42180.781     -125.68375     -125.68375    
Loop time of 123.274 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.243 hours/ns, 8.112 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.01     | 122.01     | 122.01     |   0.0 | 98.97
Neigh   | 0.64051    | 0.64051    | 0.64051    |   0.0 |  0.52
Comm    | 0.11504    | 0.11504    | 0.11504    |   0.0 |  0.09
Output  | 0.00016779 | 0.00016779 | 0.00016779 |   0.0 |  0.00
Modify  | 0.44976    | 0.44976    | 0.44976    |   0.0 |  0.36
Other   |            | 0.06194    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3810 ave        3810 max        3810 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127614 ave      127614 max      127614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127614
Ave neighs/atom = 63.807
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.439676779543, Press = 0.332898207074733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -3618.9332     -3618.9332     -3705.1562     -3705.1562      333.69188      333.69188      42180.781      42180.781     -125.68375     -125.68375    
     63000  -3622.4054     -3622.4054     -3707.5372     -3707.5372      329.46867      329.46867      41966.04       41966.04       589.05636      589.05636    
Loop time of 114.277 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.744 hours/ns, 8.751 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.12     | 113.12     | 113.12     |   0.0 | 98.99
Neigh   | 0.60844    | 0.60844    | 0.60844    |   0.0 |  0.53
Comm    | 0.10417    | 0.10417    | 0.10417    |   0.0 |  0.09
Output  | 0.00016842 | 0.00016842 | 0.00016842 |   0.0 |  0.00
Modify  | 0.38681    | 0.38681    | 0.38681    |   0.0 |  0.34
Other   |            | 0.05766    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3777 ave        3777 max        3777 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127798 ave      127798 max      127798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127798
Ave neighs/atom = 63.899
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.415978324382, Press = 0.968946633065304
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -3622.4054     -3622.4054     -3707.5372     -3707.5372      329.46867      329.46867      41966.04       41966.04       589.05636      589.05636    
     64000  -3620.5543     -3620.5543     -3706.1717     -3706.1717      331.34793      331.34793      42091.668      42091.668      210.81269      210.81269    
Loop time of 117.243 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.04     | 116.04     | 116.04     |   0.0 | 98.97
Neigh   | 0.62342    | 0.62342    | 0.62342    |   0.0 |  0.53
Comm    | 0.10943    | 0.10943    | 0.10943    |   0.0 |  0.09
Output  | 0.00016834 | 0.00016834 | 0.00016834 |   0.0 |  0.00
Modify  | 0.41075    | 0.41075    | 0.41075    |   0.0 |  0.35
Other   |            | 0.05861    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3767 ave        3767 max        3767 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127496 ave      127496 max      127496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127496
Ave neighs/atom = 63.748
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.425103808906, Press = 0.929284094937982
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -3620.5543     -3620.5543     -3706.1717     -3706.1717      331.34793      331.34793      42091.668      42091.668      210.81269      210.81269    
     65000  -3621.6218     -3621.6218     -3706.9463     -3706.9463      330.21476      330.21476      42137.587      42137.587      39.106516      39.106516    
Loop time of 109.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.493 hours/ns, 9.110 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.67     | 108.67     | 108.67     |   0.0 | 98.99
Neigh   | 0.59401    | 0.59401    | 0.59401    |   0.0 |  0.54
Comm    | 0.1002     | 0.1002     | 0.1002     |   0.0 |  0.09
Output  | 0.00016859 | 0.00016859 | 0.00016859 |   0.0 |  0.00
Modify  | 0.35871    | 0.35871    | 0.35871    |   0.0 |  0.33
Other   |            | 0.05571    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3785 ave        3785 max        3785 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127202 ave      127202 max      127202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127202
Ave neighs/atom = 63.601
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.45413452054, Press = 1.24251826014526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -3621.6218     -3621.6218     -3706.9463     -3706.9463      330.21476      330.21476      42137.587      42137.587      39.106516      39.106516    
     66000  -3622.076      -3622.076      -3707.8226     -3707.8226      331.8483       331.8483       42132.215      42132.215      41.974944      41.974944    
Loop time of 115.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.746 ns/day, 32.175 hours/ns, 8.633 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.67     | 114.67     | 114.67     |   0.0 | 99.00
Neigh   | 0.59193    | 0.59193    | 0.59193    |   0.0 |  0.51
Comm    | 0.10651    | 0.10651    | 0.10651    |   0.0 |  0.09
Output  | 0.0002059  | 0.0002059  | 0.0002059  |   0.0 |  0.00
Modify  | 0.39789    | 0.39789    | 0.39789    |   0.0 |  0.34
Other   |            | 0.05875    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3740 ave        3740 max        3740 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127460 ave      127460 max      127460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127460
Ave neighs/atom = 63.73
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.445535556319, Press = 0.665832449057794
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -3622.076      -3622.076      -3707.8226     -3707.8226      331.8483       331.8483       42132.215      42132.215      41.974944      41.974944    
     67000  -3620.609      -3620.609      -3706.7929     -3706.7929      333.54046      333.54046      42171.396      42171.396     -178.03063     -178.03063    
Loop time of 121.026 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.618 hours/ns, 8.263 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.78     | 119.78     | 119.78     |   0.0 | 98.97
Neigh   | 0.63984    | 0.63984    | 0.63984    |   0.0 |  0.53
Comm    | 0.11275    | 0.11275    | 0.11275    |   0.0 |  0.09
Output  | 0.00021063 | 0.00021063 | 0.00021063 |   0.0 |  0.00
Modify  | 0.43338    | 0.43338    | 0.43338    |   0.0 |  0.36
Other   |            | 0.06177    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3783 ave        3783 max        3783 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127332 ave      127332 max      127332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127332
Ave neighs/atom = 63.666
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.460207689466, Press = 0.447086325133674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -3620.609      -3620.609      -3706.7929     -3706.7929      333.54046      333.54046      42171.396      42171.396     -178.03063     -178.03063    
     68000  -3621.0725     -3621.0725     -3708.2638     -3708.2638      337.43939      337.43939      42192.449      42192.449     -85.090005     -85.090005    
Loop time of 119.877 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.67     | 118.67     | 118.67     |   0.0 | 99.00
Neigh   | 0.60621    | 0.60621    | 0.60621    |   0.0 |  0.51
Comm    | 0.10998    | 0.10998    | 0.10998    |   0.0 |  0.09
Output  | 0.00016635 | 0.00016635 | 0.00016635 |   0.0 |  0.00
Modify  | 0.42687    | 0.42687    | 0.42687    |   0.0 |  0.36
Other   |            | 0.06077    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3797 ave        3797 max        3797 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127394 ave      127394 max      127394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127394
Ave neighs/atom = 63.697
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.482970322527, Press = 0.970906221140187
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -3621.0725     -3621.0725     -3708.2638     -3708.2638      337.43939      337.43939      42192.449      42192.449     -85.090005     -85.090005    
     69000  -3624.1444     -3624.1444     -3708.8378     -3708.8378      327.77226      327.77226      42144.378      42144.378     -113.69038     -113.69038    
Loop time of 112.497 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.249 hours/ns, 8.889 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.35     | 111.35     | 111.35     |   0.0 | 98.98
Neigh   | 0.60353    | 0.60353    | 0.60353    |   0.0 |  0.54
Comm    | 0.10345    | 0.10345    | 0.10345    |   0.0 |  0.09
Output  | 0.00147    | 0.00147    | 0.00147    |   0.0 |  0.00
Modify  | 0.37705    | 0.37705    | 0.37705    |   0.0 |  0.34
Other   |            | 0.0576     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3747 ave        3747 max        3747 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127330 ave      127330 max      127330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127330
Ave neighs/atom = 63.665
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.467689913185, Press = 0.311928262132809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -3624.1444     -3624.1444     -3708.8378     -3708.8378      327.77226      327.77226      42144.378      42144.378     -113.69038     -113.69038    
     70000  -3621.9508     -3621.9508     -3707.8878     -3707.8878      332.58488      332.58488      41942.134      41942.134      662.00795      662.00795    
Loop time of 109.749 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.486 hours/ns, 9.112 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.64     | 108.64     | 108.64     |   0.0 | 98.99
Neigh   | 0.59519    | 0.59519    | 0.59519    |   0.0 |  0.54
Comm    | 0.099913   | 0.099913   | 0.099913   |   0.0 |  0.09
Output  | 0.00020753 | 0.00020753 | 0.00020753 |   0.0 |  0.00
Modify  | 0.35408    | 0.35408    | 0.35408    |   0.0 |  0.32
Other   |            | 0.05698    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3769 ave        3769 max        3769 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127774 ave      127774 max      127774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127774
Ave neighs/atom = 63.887
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.487865509597, Press = 0.303300834406345
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -3621.9508     -3621.9508     -3707.8878     -3707.8878      332.58488      332.58488      41942.134      41942.134      662.00795      662.00795    
     71000  -3621.2929     -3621.2929     -3709.3997     -3709.3997      340.98243      340.98243      41947.468      41947.468      604.62955      604.62955    
Loop time of 109.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.381 hours/ns, 9.143 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.27     | 108.27     | 108.27     |   0.0 | 98.99
Neigh   | 0.59254    | 0.59254    | 0.59254    |   0.0 |  0.54
Comm    | 0.098568   | 0.098568   | 0.098568   |   0.0 |  0.09
Output  | 0.00016757 | 0.00016757 | 0.00016757 |   0.0 |  0.00
Modify  | 0.35353    | 0.35353    | 0.35353    |   0.0 |  0.32
Other   |            | 0.05707    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3795 ave        3795 max        3795 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127664 ave      127664 max      127664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127664
Ave neighs/atom = 63.832
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.481190483345, Press = 0.932747183138914
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -3621.2929     -3621.2929     -3709.3997     -3709.3997      340.98243      340.98243      41947.468      41947.468      604.62955      604.62955    
     72000  -3624.6163     -3624.6163     -3709.791      -3709.791       329.63506      329.63506      42099.861      42099.861      26.554534      26.554534    
Loop time of 109.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.448 hours/ns, 9.123 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.51     | 108.51     | 108.51     |   0.0 | 98.99
Neigh   | 0.59306    | 0.59306    | 0.59306    |   0.0 |  0.54
Comm    | 0.098926   | 0.098926   | 0.098926   |   0.0 |  0.09
Output  | 0.00016733 | 0.00016733 | 0.00016733 |   0.0 |  0.00
Modify  | 0.35387    | 0.35387    | 0.35387    |   0.0 |  0.32
Other   |            | 0.05697    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3746 ave        3746 max        3746 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127442 ave      127442 max      127442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127442
Ave neighs/atom = 63.721
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.432688596107, Press = 1.32960321926486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -3624.6163     -3624.6163     -3709.791      -3709.791       329.63506      329.63506      42099.861      42099.861      26.554534      26.554534    
     73000  -3621.1228     -3621.1228     -3707.0053     -3707.0053      332.37425      332.37425      42182.38       42182.38      -79.801117     -79.801117    
Loop time of 109.257 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.349 hours/ns, 9.153 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.18     | 108.18     | 108.18     |   0.0 | 99.02
Neigh   | 0.567      | 0.567      | 0.567      |   0.0 |  0.52
Comm    | 0.098614   | 0.098614   | 0.098614   |   0.0 |  0.09
Output  | 0.00016984 | 0.00016984 | 0.00016984 |   0.0 |  0.00
Modify  | 0.35248    | 0.35248    | 0.35248    |   0.0 |  0.32
Other   |            | 0.05715    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3733 ave        3733 max        3733 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127470 ave      127470 max      127470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127470
Ave neighs/atom = 63.735
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.417836082134, Press = 0.717776452608836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -3621.1228     -3621.1228     -3707.0053     -3707.0053      332.37425      332.37425      42182.38       42182.38      -79.801117     -79.801117    
     74000  -3627.1523     -3627.1523     -3711.0948     -3711.0948      324.86605      324.86605      42163.82       42163.82      -246.4808      -246.4808     
Loop time of 109.467 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.407 hours/ns, 9.135 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.36     | 108.36     | 108.36     |   0.0 | 98.99
Neigh   | 0.59344    | 0.59344    | 0.59344    |   0.0 |  0.54
Comm    | 0.098517   | 0.098517   | 0.098517   |   0.0 |  0.09
Output  | 0.0002094  | 0.0002094  | 0.0002094  |   0.0 |  0.00
Modify  | 0.35303    | 0.35303    | 0.35303    |   0.0 |  0.32
Other   |            | 0.05699    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3751 ave        3751 max        3751 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127282 ave      127282 max      127282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127282
Ave neighs/atom = 63.641
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.376422329445, Press = 0.616445036706783
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -3627.1523     -3627.1523     -3711.0948     -3711.0948      324.86605      324.86605      42163.82       42163.82      -246.4808      -246.4808     
     75000  -3619.1063     -3619.1063     -3706.2451     -3706.2451      337.236        337.236        42266.095      42266.095     -349.13463     -349.13463    
Loop time of 109.871 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.520 hours/ns, 9.102 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    | 108.76     | 108.76     | 108.76     |   0.0 | 98.99
Neigh   | 0.59564    | 0.59564    | 0.59564    |   0.0 |  0.54
Comm    | 0.10116    | 0.10116    | 0.10116    |   0.0 |  0.09
Output  | 0.00016761 | 0.00016761 | 0.00016761 |   0.0 |  0.00
Modify  | 0.35961    | 0.35961    | 0.35961    |   0.0 |  0.33
Other   |            | 0.05622    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3741 ave        3741 max        3741 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127402 ave      127402 max      127402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127402
Ave neighs/atom = 63.701
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.366270311375, Press = 0.550560739091066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -3619.1063     -3619.1063     -3706.2451     -3706.2451      337.236        337.236        42266.095      42266.095     -349.13463     -349.13463    
     76000  -3622.2244     -3622.2244     -3709.0398     -3709.0398      335.98472      335.98472      42234.823      42234.823     -374.6907      -374.6907     
Loop time of 109.714 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.476 hours/ns, 9.115 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.63     | 108.63     | 108.63     |   0.0 | 99.01
Neigh   | 0.57058    | 0.57058    | 0.57058    |   0.0 |  0.52
Comm    | 0.099922   | 0.099922   | 0.099922   |   0.0 |  0.09
Output  | 0.00016956 | 0.00016956 | 0.00016956 |   0.0 |  0.00
Modify  | 0.35764    | 0.35764    | 0.35764    |   0.0 |  0.33
Other   |            | 0.05622    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3764 ave        3764 max        3764 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127150 ave      127150 max      127150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127150
Ave neighs/atom = 63.575
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.369346526645, Press = 0.761677677377052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -3622.2244     -3622.2244     -3709.0398     -3709.0398      335.98472      335.98472      42234.823      42234.823     -374.6907      -374.6907     
     77000  -3624.8678     -3624.8678     -3707.7303     -3707.7303      320.68651      320.68651      42174.21       42174.21      -328.30211     -328.30211    
Loop time of 109.313 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.365 hours/ns, 9.148 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.23     | 108.23     | 108.23     |   0.0 | 99.01
Neigh   | 0.56765    | 0.56765    | 0.56765    |   0.0 |  0.52
Comm    | 0.10059    | 0.10059    | 0.10059    |   0.0 |  0.09
Output  | 0.00016872 | 0.00016872 | 0.00016872 |   0.0 |  0.00
Modify  | 0.35492    | 0.35492    | 0.35492    |   0.0 |  0.32
Other   |            | 0.05664    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3762 ave        3762 max        3762 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127230 ave      127230 max      127230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127230
Ave neighs/atom = 63.615
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.400774447979, Press = -0.153567751773828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -3624.8678     -3624.8678     -3707.7303     -3707.7303      320.68651      320.68651      42174.21       42174.21      -328.30211     -328.30211    
     78000  -3621.1        -3621.1        -3706.3956     -3706.3956      330.10283      330.10283      42070.487      42070.487      267.01497      267.01497    
Loop time of 109.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.512 hours/ns, 9.104 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.74     | 108.74     | 108.74     |   0.0 | 98.99
Neigh   | 0.59323    | 0.59323    | 0.59323    |   0.0 |  0.54
Comm    | 0.10019    | 0.10019    | 0.10019    |   0.0 |  0.09
Output  | 0.00016819 | 0.00016819 | 0.00016819 |   0.0 |  0.00
Modify  | 0.35679    | 0.35679    | 0.35679    |   0.0 |  0.32
Other   |            | 0.05639    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3739 ave        3739 max        3739 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127360 ave      127360 max      127360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127360
Ave neighs/atom = 63.68
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.365376725499, Press = 0.14753797207443
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -3621.1        -3621.1        -3706.3956     -3706.3956      330.10283      330.10283      42070.487      42070.487      267.01497      267.01497    
     79000  -3621.1921     -3621.1921     -3707.7113     -3707.7113      334.8382       334.8382       41998.121      41998.121      469.96326      469.96326    
Loop time of 109.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.394 hours/ns, 9.139 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.31     | 108.31     | 108.31     |   0.0 | 98.99
Neigh   | 0.59308    | 0.59308    | 0.59308    |   0.0 |  0.54
Comm    | 0.1005     | 0.1005     | 0.1005     |   0.0 |  0.09
Output  | 0.0001699  | 0.0001699  | 0.0001699  |   0.0 |  0.00
Modify  | 0.35593    | 0.35593    | 0.35593    |   0.0 |  0.33
Other   |            | 0.05647    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3761 ave        3761 max        3761 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128056 ave      128056 max      128056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128056
Ave neighs/atom = 64.028
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.38907804233, Press = 0.288930023781267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -3621.1921     -3621.1921     -3707.7113     -3707.7113      334.8382       334.8382       41998.121      41998.121      469.96326      469.96326    
     80000  -3621.7992     -3621.7992     -3708.4164     -3708.4164      335.21747      335.21747      42091.139      42091.139      39.839684      39.839684    
Loop time of 109.543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.429 hours/ns, 9.129 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.46     | 108.46     | 108.46     |   0.0 | 99.01
Neigh   | 0.56859    | 0.56859    | 0.56859    |   0.0 |  0.52
Comm    | 0.099961   | 0.099961   | 0.099961   |   0.0 |  0.09
Output  | 0.0001676  | 0.0001676  | 0.0001676  |   0.0 |  0.00
Modify  | 0.35603    | 0.35603    | 0.35603    |   0.0 |  0.33
Other   |            | 0.05671    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3718 ave        3718 max        3718 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127846 ave      127846 max      127846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127846
Ave neighs/atom = 63.923
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.382126152412, Press = 0.744529719000472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -3621.7992     -3621.7992     -3708.4164     -3708.4164      335.21747      335.21747      42091.139      42091.139      39.839684      39.839684    
     81000  -3617.7316     -3617.7316     -3704.3185     -3704.3185      335.10014      335.10014      42200.608      42200.608     -77.766313     -77.766313    
Loop time of 114.118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.699 hours/ns, 8.763 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.97     | 112.97     | 112.97     |   0.0 | 98.99
Neigh   | 0.59541    | 0.59541    | 0.59541    |   0.0 |  0.52
Comm    | 0.10566    | 0.10566    | 0.10566    |   0.0 |  0.09
Output  | 0.0001661  | 0.0001661  | 0.0001661  |   0.0 |  0.00
Modify  | 0.39199    | 0.39199    | 0.39199    |   0.0 |  0.34
Other   |            | 0.0582     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3740 ave        3740 max        3740 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127496 ave      127496 max      127496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127496
Ave neighs/atom = 63.748
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.409301648686, Press = 0.436073174173845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -3617.7316     -3617.7316     -3704.3185     -3704.3185      335.10014      335.10014      42200.608      42200.608     -77.766313     -77.766313    
     82000  -3625.1953     -3625.1953     -3711.1407     -3711.1407      332.61768      332.61768      42008.132      42008.132      269.38504      269.38504    
Loop time of 115.306 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.749 ns/day, 32.029 hours/ns, 8.673 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    | 114.13     | 114.13     | 114.13     |   0.0 | 98.98
Neigh   | 0.61631    | 0.61631    | 0.61631    |   0.0 |  0.53
Comm    | 0.10547    | 0.10547    | 0.10547    |   0.0 |  0.09
Output  | 0.00016995 | 0.00016995 | 0.00016995 |   0.0 |  0.00
Modify  | 0.3954     | 0.3954     | 0.3954     |   0.0 |  0.34
Other   |            | 0.05914    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3776 ave        3776 max        3776 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127496 ave      127496 max      127496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127496
Ave neighs/atom = 63.748
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.410073225179, Press = 0.108706550563161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -3625.1953     -3625.1953     -3711.1407     -3711.1407      332.61768      332.61768      42008.132      42008.132      269.38504      269.38504    
     83000  -3619.7967     -3619.7967     -3708.8438     -3708.8438      344.62149      344.62149      41928.481      41928.481      702.02746      702.02746    
Loop time of 123.408 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.280 hours/ns, 8.103 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.14     | 122.14     | 122.14     |   0.0 | 98.97
Neigh   | 0.64451    | 0.64451    | 0.64451    |   0.0 |  0.52
Comm    | 0.11446    | 0.11446    | 0.11446    |   0.0 |  0.09
Output  | 0.00024407 | 0.00024407 | 0.00024407 |   0.0 |  0.00
Modify  | 0.45094    | 0.45094    | 0.45094    |   0.0 |  0.37
Other   |            | 0.06248    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3772 ave        3772 max        3772 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127966 ave      127966 max      127966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127966
Ave neighs/atom = 63.983
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.399652041574, Press = 0.296440986823242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -3619.7967     -3619.7967     -3708.8438     -3708.8438      344.62149      344.62149      41928.481      41928.481      702.02746      702.02746    
     84000  -3618.058      -3618.058      -3705.2351     -3705.2351      337.38434      337.38434      42082.801      42082.801      270.18141      270.18141    
Loop time of 123.648 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.347 hours/ns, 8.087 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.37     | 122.37     | 122.37     |   0.0 | 98.97
Neigh   | 0.64495    | 0.64495    | 0.64495    |   0.0 |  0.52
Comm    | 0.11471    | 0.11471    | 0.11471    |   0.0 |  0.09
Output  | 0.00016839 | 0.00016839 | 0.00016839 |   0.0 |  0.00
Modify  | 0.45291    | 0.45291    | 0.45291    |   0.0 |  0.37
Other   |            | 0.0618     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3755 ave        3755 max        3755 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127710 ave      127710 max      127710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127710
Ave neighs/atom = 63.855
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.404435146889, Press = 1.16787946014211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -3618.058      -3618.058      -3705.2351     -3705.2351      337.38434      337.38434      42082.801      42082.801      270.18141      270.18141    
     85000  -3622.4837     -3622.4837     -3709.9324     -3709.9324      338.43558      338.43558      42174.94       42174.94      -173.30883     -173.30883    
Loop time of 123.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.258 hours/ns, 8.108 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.06     | 122.06     | 122.06     |   0.0 | 98.97
Neigh   | 0.64781    | 0.64781    | 0.64781    |   0.0 |  0.53
Comm    | 0.11427    | 0.11427    | 0.11427    |   0.0 |  0.09
Output  | 0.00017172 | 0.00017172 | 0.00017172 |   0.0 |  0.00
Modify  | 0.45109    | 0.45109    | 0.45109    |   0.0 |  0.37
Other   |            | 0.0618     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3726 ave        3726 max        3726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127218 ave      127218 max      127218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127218
Ave neighs/atom = 63.609
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.42699725812, Press = 0.738442142258531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -3622.4837     -3622.4837     -3709.9324     -3709.9324      338.43558      338.43558      42174.94       42174.94      -173.30883     -173.30883    
     86000  -3617.5845     -3617.5845     -3706.7186     -3706.7186      344.95807      344.95807      42312.363      42312.363     -474.39202     -474.39202    
Loop time of 123.541 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.317 hours/ns, 8.094 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.27     | 122.27     | 122.27     |   0.0 | 98.97
Neigh   | 0.64622    | 0.64622    | 0.64622    |   0.0 |  0.52
Comm    | 0.11387    | 0.11387    | 0.11387    |   0.0 |  0.09
Output  | 0.00025169 | 0.00025169 | 0.00025169 |   0.0 |  0.00
Modify  | 0.44866    | 0.44866    | 0.44866    |   0.0 |  0.36
Other   |            | 0.06176    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3718 ave        3718 max        3718 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127006 ave      127006 max      127006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127006
Ave neighs/atom = 63.503
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.440550515796, Press = 0.607881899657843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -3617.5845     -3617.5845     -3706.7186     -3706.7186      344.95807      344.95807      42312.363      42312.363     -474.39202     -474.39202    
     87000  -3622.9193     -3622.9193     -3709.0921     -3709.0921      333.49749      333.49749      42203.258      42203.258     -283.65185     -283.65185    
Loop time of 123.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.265 hours/ns, 8.107 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.07     | 122.07     | 122.07     |   0.0 | 98.96
Neigh   | 0.6496     | 0.6496     | 0.6496     |   0.0 |  0.53
Comm    | 0.11425    | 0.11425    | 0.11425    |   0.0 |  0.09
Output  | 0.00025192 | 0.00025192 | 0.00025192 |   0.0 |  0.00
Modify  | 0.45191    | 0.45191    | 0.45191    |   0.0 |  0.37
Other   |            | 0.06216    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3799 ave        3799 max        3799 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127330 ave      127330 max      127330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127330
Ave neighs/atom = 63.665
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.446902432056, Press = 0.411055905855924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -3622.9193     -3622.9193     -3709.0921     -3709.0921      333.49749      333.49749      42203.258      42203.258     -283.65185     -283.65185    
     88000  -3618.0298     -3618.0298     -3706.7772     -3706.7772      343.46129      343.46129      42203.846      42203.846     -181.13441     -181.13441    
Loop time of 119.772 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.54     | 118.54     | 118.54     |   0.0 | 98.97
Neigh   | 0.63186    | 0.63186    | 0.63186    |   0.0 |  0.53
Comm    | 0.11157    | 0.11157    | 0.11157    |   0.0 |  0.09
Output  | 0.00017012 | 0.00017012 | 0.00017012 |   0.0 |  0.00
Modify  | 0.4287     | 0.4287     | 0.4287     |   0.0 |  0.36
Other   |            | 0.06055    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3731 ave        3731 max        3731 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127178 ave      127178 max      127178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127178
Ave neighs/atom = 63.589
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.471571377536, Press = 0.151979933536254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -3618.0298     -3618.0298     -3706.7772     -3706.7772      343.46129      343.46129      42203.846      42203.846     -181.13441     -181.13441    
     89000  -3619.7722     -3619.7722     -3707.9765     -3707.9765      341.3597       341.3597       42002.654      42002.654      444.07683      444.07683    
Loop time of 109.733 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.481 hours/ns, 9.113 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.65     | 108.65     | 108.65     |   0.0 | 99.01
Neigh   | 0.5687     | 0.5687     | 0.5687     |   0.0 |  0.52
Comm    | 0.099967   | 0.099967   | 0.099967   |   0.0 |  0.09
Output  | 0.00016804 | 0.00016804 | 0.00016804 |   0.0 |  0.00
Modify  | 0.35733    | 0.35733    | 0.35733    |   0.0 |  0.33
Other   |            | 0.05552    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3776 ave        3776 max        3776 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127430 ave      127430 max      127430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127430
Ave neighs/atom = 63.715
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.471560774335, Press = 0.350412479527257
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -3619.7722     -3619.7722     -3707.9765     -3707.9765      341.3597       341.3597       42002.654      42002.654      444.07683      444.07683    
     90000  -3620.409      -3620.409      -3708.5602     -3708.5602      341.1542       341.1542       41818.489      41818.489      1023.7969      1023.7969    
Loop time of 109.819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.505 hours/ns, 9.106 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.71     | 108.71     | 108.71     |   0.0 | 98.99
Neigh   | 0.59468    | 0.59468    | 0.59468    |   0.0 |  0.54
Comm    | 0.10007    | 0.10007    | 0.10007    |   0.0 |  0.09
Output  | 0.00016765 | 0.00016765 | 0.00016765 |   0.0 |  0.00
Modify  | 0.35804    | 0.35804    | 0.35804    |   0.0 |  0.33
Other   |            | 0.05531    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3796 ave        3796 max        3796 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128216 ave      128216 max      128216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128216
Ave neighs/atom = 64.108
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.494824469618, Press = 1.12338248523747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -3620.409      -3620.409      -3708.5602     -3708.5602      341.1542       341.1542       41818.489      41818.489      1023.7969      1023.7969    
     91000  -3620.7226     -3620.7226     -3708.5539     -3708.5539      339.9161       339.9161       42135.842      42135.842     -77.034809     -77.034809    
Loop time of 109.674 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.465 hours/ns, 9.118 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.57     | 108.57     | 108.57     |   0.0 | 98.99
Neigh   | 0.59476    | 0.59476    | 0.59476    |   0.0 |  0.54
Comm    | 0.10021    | 0.10021    | 0.10021    |   0.0 |  0.09
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.35663    | 0.35663    | 0.35663    |   0.0 |  0.33
Other   |            | 0.05552    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3760 ave        3760 max        3760 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127554 ave      127554 max      127554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127554
Ave neighs/atom = 63.777
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.500748687594, Press = 1.42575340660575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -3620.7226     -3620.7226     -3708.5539     -3708.5539      339.9161       339.9161       42135.842      42135.842     -77.034809     -77.034809    
     92000  -3622.851      -3622.851      -3706.9639     -3706.9639      325.52555      325.52555      42178.348      42178.348     -266.12654     -266.12654    
Loop time of 109.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.459 hours/ns, 9.120 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.55     | 108.55     | 108.55     |   0.0 | 98.99
Neigh   | 0.59375    | 0.59375    | 0.59375    |   0.0 |  0.54
Comm    | 0.10012    | 0.10012    | 0.10012    |   0.0 |  0.09
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.35748    | 0.35748    | 0.35748    |   0.0 |  0.33
Other   |            | 0.05548    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3773 ave        3773 max        3773 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127284 ave      127284 max      127284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127284
Ave neighs/atom = 63.642
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.50285682483, Press = 0.836996295732429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -3622.851      -3622.851      -3706.9639     -3706.9639      325.52555      325.52555      42178.348      42178.348     -266.12654     -266.12654    
     93000  -3618.9387     -3618.9387     -3702.8645     -3702.8645      324.80153      324.80153      42239.332      42239.332     -223.8684      -223.8684     
Loop time of 109.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.486 hours/ns, 9.112 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.64     | 108.64     | 108.64     |   0.0 | 98.99
Neigh   | 0.59357    | 0.59357    | 0.59357    |   0.0 |  0.54
Comm    | 0.10033    | 0.10033    | 0.10033    |   0.0 |  0.09
Output  | 0.00020732 | 0.00020732 | 0.00020732 |   0.0 |  0.00
Modify  | 0.35702    | 0.35702    | 0.35702    |   0.0 |  0.33
Other   |            | 0.05555    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3694 ave        3694 max        3694 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127406 ave      127406 max      127406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127406
Ave neighs/atom = 63.703
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.496225146542, Press = 0.557914723426806
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -3618.9387     -3618.9387     -3702.8645     -3702.8645      324.80153      324.80153      42239.332      42239.332     -223.8684      -223.8684     
     94000  -3625.8673     -3625.8673     -3708.4641     -3708.4641      319.65805      319.65805      42061.027      42061.027      92.949249      92.949249    
Loop time of 109.97 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.547 hours/ns, 9.093 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.86     | 108.86     | 108.86     |   0.0 | 98.99
Neigh   | 0.59396    | 0.59396    | 0.59396    |   0.0 |  0.54
Comm    | 0.10069    | 0.10069    | 0.10069    |   0.0 |  0.09
Output  | 0.00016924 | 0.00016924 | 0.00016924 |   0.0 |  0.00
Modify  | 0.35545    | 0.35545    | 0.35545    |   0.0 |  0.32
Other   |            | 0.05596    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3744 ave        3744 max        3744 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127522 ave      127522 max      127522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127522
Ave neighs/atom = 63.761
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.468650535273, Press = 0.692431334659785
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -3625.8673     -3625.8673     -3708.4641     -3708.4641      319.65805      319.65805      42061.027      42061.027      92.949249      92.949249    
     95000  -3619.7124     -3619.7124     -3705.7186     -3705.7186      332.85302      332.85302      42277.902      42277.902     -394.03073     -394.03073    
Loop time of 109.897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.527 hours/ns, 9.099 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.81     | 108.81     | 108.81     |   0.0 | 99.01
Neigh   | 0.57021    | 0.57021    | 0.57021    |   0.0 |  0.52
Comm    | 0.099539   | 0.099539   | 0.099539   |   0.0 |  0.09
Output  | 0.000171   | 0.000171   | 0.000171   |   0.0 |  0.00
Modify  | 0.35757    | 0.35757    | 0.35757    |   0.0 |  0.33
Other   |            | 0.05535    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3736 ave        3736 max        3736 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127144 ave      127144 max      127144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127144
Ave neighs/atom = 63.572
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.450213406634, Press = 0.287579319338757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -3619.7124     -3619.7124     -3705.7186     -3705.7186      332.85302      332.85302      42277.902      42277.902     -394.03073     -394.03073    
     96000  -3623.0103     -3623.0103     -3708.7447     -3708.7447      331.80098      331.80098      42143.396      42143.396     -169.31328     -169.31328    
Loop time of 109.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.542 hours/ns, 9.095 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.84     | 108.84     | 108.84     |   0.0 | 98.99
Neigh   | 0.59357    | 0.59357    | 0.59357    |   0.0 |  0.54
Comm    | 0.10003    | 0.10003    | 0.10003    |   0.0 |  0.09
Output  | 0.00016829 | 0.00016829 | 0.00016829 |   0.0 |  0.00
Modify  | 0.35548    | 0.35548    | 0.35548    |   0.0 |  0.32
Other   |            | 0.056      |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3756 ave        3756 max        3756 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127452 ave      127452 max      127452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127452
Ave neighs/atom = 63.726
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.426496437172, Press = 0.29172893820635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -3623.0103     -3623.0103     -3708.7447     -3708.7447      331.80098      331.80098      42143.396      42143.396     -169.31328     -169.31328    
     97000  -3620.7691     -3620.7691     -3707.7805     -3707.7805      336.743        336.743        41988.861      41988.861      402.13415      402.13415    
Loop time of 109.852 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.514 hours/ns, 9.103 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.77     | 108.77     | 108.77     |   0.0 | 99.01
Neigh   | 0.56937    | 0.56937    | 0.56937    |   0.0 |  0.52
Comm    | 0.1001     | 0.1001     | 0.1001     |   0.0 |  0.09
Output  | 0.00020194 | 0.00020194 | 0.00020194 |   0.0 |  0.00
Modify  | 0.35656    | 0.35656    | 0.35656    |   0.0 |  0.32
Other   |            | 0.05587    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3791 ave        3791 max        3791 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127650 ave      127650 max      127650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127650
Ave neighs/atom = 63.825
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.427631095385, Press = 0.300464071268673
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -3620.7691     -3620.7691     -3707.7805     -3707.7805      336.743        336.743        41988.861      41988.861      402.13415      402.13415    
     98000  -3626.7669     -3626.7669     -3710.8101     -3710.8101      325.2558       325.2558       41893.548      41893.548      588.2087       588.2087     
Loop time of 117.442 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.27     | 116.27     | 116.27     |   0.0 | 99.01
Neigh   | 0.59684    | 0.59684    | 0.59684    |   0.0 |  0.51
Comm    | 0.10754    | 0.10754    | 0.10754    |   0.0 |  0.09
Output  | 0.00020966 | 0.00020966 | 0.00020966 |   0.0 |  0.00
Modify  | 0.40396    | 0.40396    | 0.40396    |   0.0 |  0.34
Other   |            | 0.05919    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3786 ave        3786 max        3786 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127818 ave      127818 max      127818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127818
Ave neighs/atom = 63.909
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.395961168509, Press = 0.981380190719179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -3626.7669     -3626.7669     -3710.8101     -3710.8101      325.2558       325.2558       41893.548      41893.548      588.2087       588.2087     
     99000  -3621.8395     -3621.8395     -3709.8844     -3709.8844      340.7428       340.7428       42113.065      42113.065      49.813135      49.813135    
Loop time of 123.042 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.178 hours/ns, 8.127 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.77     | 121.77     | 121.77     |   0.0 | 98.97
Neigh   | 0.63878    | 0.63878    | 0.63878    |   0.0 |  0.52
Comm    | 0.11393    | 0.11393    | 0.11393    |   0.0 |  0.09
Output  | 0.00020598 | 0.00020598 | 0.00020598 |   0.0 |  0.00
Modify  | 0.45225    | 0.45225    | 0.45225    |   0.0 |  0.37
Other   |            | 0.06214    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3765 ave        3765 max        3765 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127492 ave      127492 max      127492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127492
Ave neighs/atom = 63.746
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.387014905222, Press = 0.984270314060602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -3621.8395     -3621.8395     -3709.8844     -3709.8844      340.7428       340.7428       42113.065      42113.065      49.813135      49.813135    
    100000  -3623.546      -3623.546      -3708.6771     -3708.6771      329.46618      329.46618      42355.23       42355.23      -736.52331     -736.52331    
Loop time of 122.857 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.127 hours/ns, 8.140 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.59     | 121.59     | 121.59     |   0.0 | 98.97
Neigh   | 0.64352    | 0.64352    | 0.64352    |   0.0 |  0.52
Comm    | 0.11375    | 0.11375    | 0.11375    |   0.0 |  0.09
Output  | 0.00016913 | 0.00016913 | 0.00016913 |   0.0 |  0.00
Modify  | 0.44953    | 0.44953    | 0.44953    |   0.0 |  0.37
Other   |            | 0.06129    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3740 ave        3740 max        3740 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127128 ave      127128 max      127128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127128
Ave neighs/atom = 63.564
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.390589595598, Press = 0.92995864107437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -3623.546      -3623.546      -3708.6771     -3708.6771      329.46618      329.46618      42355.23       42355.23      -736.52331     -736.52331    
    101000  -3625.1732     -3625.1732     -3708.0299     -3708.0299      320.66406      320.66406      42314.909      42314.909     -625.61999     -625.61999    
Loop time of 122.916 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.143 hours/ns, 8.136 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.65     | 121.65     | 121.65     |   0.0 | 98.97
Neigh   | 0.64031    | 0.64031    | 0.64031    |   0.0 |  0.52
Comm    | 0.11466    | 0.11466    | 0.11466    |   0.0 |  0.09
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.44974    | 0.44974    | 0.44974    |   0.0 |  0.37
Other   |            | 0.06156    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3763 ave        3763 max        3763 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126686 ave      126686 max      126686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126686
Ave neighs/atom = 63.343
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.374599879775, Press = 0.304502779284029
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -3625.1732     -3625.1732     -3708.0299     -3708.0299      320.66406      320.66406      42314.909      42314.909     -625.61999     -625.61999    
    102000  -3622.9034     -3622.9034     -3708.5056     -3708.5056      331.28973      331.28973      42005.41       42005.41       334.58703      334.58703    
Loop time of 111.107 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.778 ns/day, 30.863 hours/ns, 9.000 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.99     | 109.99     | 109.99     |   0.0 | 98.99
Neigh   | 0.59853    | 0.59853    | 0.59853    |   0.0 |  0.54
Comm    | 0.10126    | 0.10126    | 0.10126    |   0.0 |  0.09
Output  | 0.00016768 | 0.00016768 | 0.00016768 |   0.0 |  0.00
Modify  | 0.36394    | 0.36394    | 0.36394    |   0.0 |  0.33
Other   |            | 0.05766    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3785 ave        3785 max        3785 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127608 ave      127608 max      127608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127608
Ave neighs/atom = 63.804
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.373982508821, Press = 0.20557186659485
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -3622.9034     -3622.9034     -3708.5056     -3708.5056      331.28973      331.28973      42005.41       42005.41       334.58703      334.58703    
    103000  -3617.9823     -3617.9823     -3704.9882     -3704.9882      336.72208      336.72208      42099.753      42099.753      349.99869      349.99869    
Loop time of 115.601 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.111 hours/ns, 8.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    | 114.42     | 114.42     | 114.42     |   0.0 | 98.98
Neigh   | 0.61609    | 0.61609    | 0.61609    |   0.0 |  0.53
Comm    | 0.10607    | 0.10607    | 0.10607    |   0.0 |  0.09
Output  | 0.00016923 | 0.00016923 | 0.00016923 |   0.0 |  0.00
Modify  | 0.39686    | 0.39686    | 0.39686    |   0.0 |  0.34
Other   |            | 0.05943    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3720 ave        3720 max        3720 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127320 ave      127320 max      127320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127320
Ave neighs/atom = 63.66
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.399559888968, Press = 0.527773530029094
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -3617.9823     -3617.9823     -3704.9882     -3704.9882      336.72208      336.72208      42099.753      42099.753      349.99869      349.99869    
    104000  -3625.1712     -3625.1712     -3708.6554     -3708.6554      323.09224      323.09224      42017.77       42017.77       262.74376      262.74376    
Loop time of 123.382 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.273 hours/ns, 8.105 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.1      | 122.1      | 122.1      |   0.0 | 98.96
Neigh   | 0.64858    | 0.64858    | 0.64858    |   0.0 |  0.53
Comm    | 0.11567    | 0.11567    | 0.11567    |   0.0 |  0.09
Output  | 0.00016784 | 0.00016784 | 0.00016784 |   0.0 |  0.00
Modify  | 0.45516    | 0.45516    | 0.45516    |   0.0 |  0.37
Other   |            | 0.06238    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3795 ave        3795 max        3795 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127648 ave      127648 max      127648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127648
Ave neighs/atom = 63.824
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.404800072069, Press = 0.674315157301746
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -3625.1712     -3625.1712     -3708.6554     -3708.6554      323.09224      323.09224      42017.77       42017.77       262.74376      262.74376    
    105000  -3620.7563     -3620.7563     -3707.1451     -3707.1451      334.33393      334.33393      42084.68       42084.68       145.20614      145.20614    
Loop time of 123.553 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.320 hours/ns, 8.094 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.27     | 122.27     | 122.27     |   0.0 | 98.96
Neigh   | 0.64928    | 0.64928    | 0.64928    |   0.0 |  0.53
Comm    | 0.11623    | 0.11623    | 0.11623    |   0.0 |  0.09
Output  | 0.00020767 | 0.00020767 | 0.00020767 |   0.0 |  0.00
Modify  | 0.45205    | 0.45205    | 0.45205    |   0.0 |  0.37
Other   |            | 0.06339    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3807 ave        3807 max        3807 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127716 ave      127716 max      127716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127716
Ave neighs/atom = 63.858
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.391615581602, Press = 0.696809355393189
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -3620.7563     -3620.7563     -3707.1451     -3707.1451      334.33393      334.33393      42084.68       42084.68       145.20614      145.20614    
    106000  -3620.8736     -3620.8736     -3709.194      -3709.194       341.80909      341.80909      42149.606      42149.606     -14.190918     -14.190918    
Loop time of 123.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.291 hours/ns, 8.100 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.18     | 122.18     | 122.18     |   0.0 | 98.97
Neigh   | 0.64336    | 0.64336    | 0.64336    |   0.0 |  0.52
Comm    | 0.11637    | 0.11637    | 0.11637    |   0.0 |  0.09
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.44974    | 0.44974    | 0.44974    |   0.0 |  0.36
Other   |            | 0.06224    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3776 ave        3776 max        3776 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127494 ave      127494 max      127494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127494
Ave neighs/atom = 63.747
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.417306055863, Press = 0.644120256631276
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -3620.8736     -3620.8736     -3709.194      -3709.194       341.80909      341.80909      42149.606      42149.606     -14.190918     -14.190918    
    107000  -3622.008      -3622.008      -3707.6016     -3707.6016      331.256        331.256        42202.538      42202.538     -357.56643     -357.56643    
Loop time of 123.365 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.268 hours/ns, 8.106 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.12     | 122.12     | 122.12     |   0.0 | 98.99
Neigh   | 0.6171     | 0.6171     | 0.6171     |   0.0 |  0.50
Comm    | 0.11406    | 0.11406    | 0.11406    |   0.0 |  0.09
Output  | 0.00027348 | 0.00027348 | 0.00027348 |   0.0 |  0.00
Modify  | 0.44893    | 0.44893    | 0.44893    |   0.0 |  0.36
Other   |            | 0.0618     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3752 ave        3752 max        3752 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127448 ave      127448 max      127448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127448
Ave neighs/atom = 63.724
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.424420678667, Press = 0.759273968021733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -3622.008      -3622.008      -3707.6016     -3707.6016      331.256        331.256        42202.538      42202.538     -357.56643     -357.56643    
    108000  -3623.2524     -3623.2524     -3707.956      -3707.956       327.81166      327.81166      42295.45       42295.45      -539.5738      -539.5738     
Loop time of 123.115 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.199 hours/ns, 8.122 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.84     | 121.84     | 121.84     |   0.0 | 98.96
Neigh   | 0.64775    | 0.64775    | 0.64775    |   0.0 |  0.53
Comm    | 0.11396    | 0.11396    | 0.11396    |   0.0 |  0.09
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.45098    | 0.45098    | 0.45098    |   0.0 |  0.37
Other   |            | 0.06254    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3736 ave        3736 max        3736 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126906 ave      126906 max      126906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126906
Ave neighs/atom = 63.453
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.448494526956, Press = 0.0255497154936896
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -3623.2524     -3623.2524     -3707.956      -3707.956       327.81166      327.81166      42295.45       42295.45      -539.5738      -539.5738     
    109000  -3619.5153     -3619.5153     -3706.1935     -3706.1935      335.45355      335.45355      42128.02       42128.02       192.01366      192.01366    
Loop time of 123.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.265 hours/ns, 8.107 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.08     | 122.08     | 122.08     |   0.0 | 98.97
Neigh   | 0.64214    | 0.64214    | 0.64214    |   0.0 |  0.52
Comm    | 0.11419    | 0.11419    | 0.11419    |   0.0 |  0.09
Output  | 0.00020458 | 0.00020458 | 0.00020458 |   0.0 |  0.00
Modify  | 0.45264    | 0.45264    | 0.45264    |   0.0 |  0.37
Other   |            | 0.06217    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3748 ave        3748 max        3748 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127504 ave      127504 max      127504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127504
Ave neighs/atom = 63.752
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.459484136517, Press = 0.0684675099383956
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -3619.5153     -3619.5153     -3706.1935     -3706.1935      335.45355      335.45355      42128.02       42128.02       192.01366      192.01366    
    110000  -3621.9162     -3621.9162     -3707.9976     -3707.9976      333.14401      333.14401      41980.239      41980.239      504.02732      504.02732    
Loop time of 111.161 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.777 ns/day, 30.878 hours/ns, 8.996 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.04     | 110.04     | 110.04     |   0.0 | 98.99
Neigh   | 0.59662    | 0.59662    | 0.59662    |   0.0 |  0.54
Comm    | 0.10161    | 0.10161    | 0.10161    |   0.0 |  0.09
Output  | 0.00021052 | 0.00021052 | 0.00021052 |   0.0 |  0.00
Modify  | 0.36489    | 0.36489    | 0.36489    |   0.0 |  0.33
Other   |            | 0.0572     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3771 ave        3771 max        3771 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127698 ave      127698 max      127698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127698
Ave neighs/atom = 63.849
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.461550095005, Press = 0.564227967928754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -3621.9162     -3621.9162     -3707.9976     -3707.9976      333.14401      333.14401      41980.239      41980.239      504.02732      504.02732    
    111000  -3617.2287     -3617.2287     -3706.1091     -3706.1091      343.97652      343.97652      42148.571      42148.571     -41.768096     -41.768096    
Loop time of 115.9 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.745 ns/day, 32.194 hours/ns, 8.628 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.74     | 114.74     | 114.74     |   0.0 | 99.00
Neigh   | 0.5926     | 0.5926     | 0.5926     |   0.0 |  0.51
Comm    | 0.10565    | 0.10565    | 0.10565    |   0.0 |  0.09
Output  | 0.00016865 | 0.00016865 | 0.00016865 |   0.0 |  0.00
Modify  | 0.39874    | 0.39874    | 0.39874    |   0.0 |  0.34
Other   |            | 0.05984    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3791 ave        3791 max        3791 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127714 ave      127714 max      127714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127714
Ave neighs/atom = 63.857
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.484693841574, Press = 0.511559382379645
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -3617.2287     -3617.2287     -3706.1091     -3706.1091      343.97652      343.97652      42148.571      42148.571     -41.768096     -41.768096    
    112000  -3621.0762     -3621.0762     -3706.1881     -3706.1881      329.39182      329.39182      42173.523      42173.523     -31.896457     -31.896457    
Loop time of 122.963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.156 hours/ns, 8.133 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.71     | 121.71     | 121.71     |   0.0 | 98.98
Neigh   | 0.64236    | 0.64236    | 0.64236    |   0.0 |  0.52
Comm    | 0.11227    | 0.11227    | 0.11227    |   0.0 |  0.09
Output  | 0.00016844 | 0.00016844 | 0.00016844 |   0.0 |  0.00
Modify  | 0.44095    | 0.44095    | 0.44095    |   0.0 |  0.36
Other   |            | 0.06149    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3751 ave        3751 max        3751 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127224 ave      127224 max      127224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127224
Ave neighs/atom = 63.612
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.478163994197, Press = 0.720616717651067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -3621.0762     -3621.0762     -3706.1881     -3706.1881      329.39182      329.39182      42173.523      42173.523     -31.896457     -31.896457    
    113000  -3623.1973     -3623.1973     -3708.339      -3708.339       329.50708      329.50708      42079.203      42079.203      245.6719       245.6719     
Loop time of 120.745 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.540 hours/ns, 8.282 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.53     | 119.53     | 119.53     |   0.0 | 98.99
Neigh   | 0.61089    | 0.61089    | 0.61089    |   0.0 |  0.51
Comm    | 0.11101    | 0.11101    | 0.11101    |   0.0 |  0.09
Output  | 0.00020521 | 0.00020521 | 0.00020521 |   0.0 |  0.00
Modify  | 0.43341    | 0.43341    | 0.43341    |   0.0 |  0.36
Other   |            | 0.06124    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3787 ave        3787 max        3787 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127676 ave      127676 max      127676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127676
Ave neighs/atom = 63.838
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.491536189362, Press = 0.649832027514963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -3623.1973     -3623.1973     -3708.339      -3708.339       329.50708      329.50708      42079.203      42079.203      245.6719       245.6719     
    114000  -3616.3396     -3616.3396     -3704.8672     -3704.8672      342.61131      342.61131      42278.227      42278.227     -240.18099     -240.18099    
Loop time of 110.299 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.783 ns/day, 30.638 hours/ns, 9.066 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.18     | 109.18     | 109.18     |   0.0 | 98.99
Neigh   | 0.59576    | 0.59576    | 0.59576    |   0.0 |  0.54
Comm    | 0.10133    | 0.10133    | 0.10133    |   0.0 |  0.09
Output  | 0.00016827 | 0.00016827 | 0.00016827 |   0.0 |  0.00
Modify  | 0.36309    | 0.36309    | 0.36309    |   0.0 |  0.33
Other   |            | 0.05584    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3758 ave        3758 max        3758 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127274 ave      127274 max      127274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127274
Ave neighs/atom = 63.637
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.512134863484, Press = 0.637169025177889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -3616.3396     -3616.3396     -3704.8672     -3704.8672      342.61131      342.61131      42278.227      42278.227     -240.18099     -240.18099    
    115000  -3622.771      -3622.771      -3709.2473     -3709.2473      334.67188      334.67188      42261.799      42261.799     -515.1457      -515.1457     
Loop time of 109.772 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.492 hours/ns, 9.110 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.66     | 108.66     | 108.66     |   0.0 | 98.99
Neigh   | 0.59347    | 0.59347    | 0.59347    |   0.0 |  0.54
Comm    | 0.10081    | 0.10081    | 0.10081    |   0.0 |  0.09
Output  | 0.00016673 | 0.00016673 | 0.00016673 |   0.0 |  0.00
Modify  | 0.35877    | 0.35877    | 0.35877    |   0.0 |  0.33
Other   |            | 0.05554    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3761 ave        3761 max        3761 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127228 ave      127228 max      127228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127228
Ave neighs/atom = 63.614
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.51878756033, Press = 0.256658806361917
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -3622.771      -3622.771      -3709.2473     -3709.2473      334.67188      334.67188      42261.799      42261.799     -515.1457      -515.1457     
    116000  -3619.008      -3619.008      -3705.5128     -3705.5128      334.78224      334.78224      42227.304      42227.304     -288.50095     -288.50095    
Loop time of 118.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.813 hours/ns, 8.465 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.92     | 116.92     | 116.92     |   0.0 | 98.98
Neigh   | 0.62648    | 0.62648    | 0.62648    |   0.0 |  0.53
Comm    | 0.10893    | 0.10893    | 0.10893    |   0.0 |  0.09
Output  | 0.00020387 | 0.00020387 | 0.00020387 |   0.0 |  0.00
Modify  | 0.41323    | 0.41323    | 0.41323    |   0.0 |  0.35
Other   |            | 0.05927    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3720 ave        3720 max        3720 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127318 ave      127318 max      127318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127318
Ave neighs/atom = 63.659
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.52822930612, Press = 0.0402580541464589
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -3619.008      -3619.008      -3705.5128     -3705.5128      334.78224      334.78224      42227.304      42227.304     -288.50095     -288.50095    
    117000  -3620.5077     -3620.5077     -3708.0242     -3708.0242      338.69796      338.69796      42058.575      42058.575      327.72589      327.72589    
Loop time of 122.128 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.707 ns/day, 33.924 hours/ns, 8.188 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.86     | 120.86     | 120.86     |   0.0 | 98.97
Neigh   | 0.64052    | 0.64052    | 0.64052    |   0.0 |  0.52
Comm    | 0.11429    | 0.11429    | 0.11429    |   0.0 |  0.09
Output  | 0.00016683 | 0.00016683 | 0.00016683 |   0.0 |  0.00
Modify  | 0.44718    | 0.44718    | 0.44718    |   0.0 |  0.37
Other   |            | 0.06145    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3742 ave        3742 max        3742 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127488 ave      127488 max      127488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127488
Ave neighs/atom = 63.744
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.530426381312, Press = 0.193128942871429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -3620.5077     -3620.5077     -3708.0242     -3708.0242      338.69796      338.69796      42058.575      42058.575      327.72589      327.72589    
    118000  -3620.7398     -3620.7398     -3706.0773     -3706.0773      330.265        330.265        41998.962      41998.962      512.51851      512.51851    
Loop time of 114.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.753 ns/day, 31.864 hours/ns, 8.718 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.54     | 113.54     | 113.54     |   0.0 | 98.98
Neigh   | 0.61221    | 0.61221    | 0.61221    |   0.0 |  0.53
Comm    | 0.10615    | 0.10615    | 0.10615    |   0.0 |  0.09
Output  | 0.00016802 | 0.00016802 | 0.00016802 |   0.0 |  0.00
Modify  | 0.39218    | 0.39218    | 0.39218    |   0.0 |  0.34
Other   |            | 0.05823    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3770 ave        3770 max        3770 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127420 ave      127420 max      127420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127420
Ave neighs/atom = 63.71
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.56347093673, Press = 0.206289154714212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -3620.7398     -3620.7398     -3706.0773     -3706.0773      330.265        330.265        41998.962      41998.962      512.51851      512.51851    
    119000  -3622.6536     -3622.6536     -3710.0325     -3710.0325      338.16544      338.16544      42042.597      42042.597      298.37699      298.37699    
Loop time of 123.66 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.350 hours/ns, 8.087 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.39     | 122.39     | 122.39     |   0.0 | 98.97
Neigh   | 0.64543    | 0.64543    | 0.64543    |   0.0 |  0.52
Comm    | 0.11465    | 0.11465    | 0.11465    |   0.0 |  0.09
Output  | 0.00020663 | 0.00020663 | 0.00020663 |   0.0 |  0.00
Modify  | 0.44886    | 0.44886    | 0.44886    |   0.0 |  0.36
Other   |            | 0.06162    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3756 ave        3756 max        3756 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127444 ave      127444 max      127444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127444
Ave neighs/atom = 63.722
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.556257160486, Press = 0.753347052431063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -3622.6536     -3622.6536     -3710.0325     -3710.0325      338.16544      338.16544      42042.597      42042.597      298.37699      298.37699    
    120000  -3622.8868     -3622.8868     -3707.7609     -3707.7609      328.47153      328.47153      42204.078      42204.078     -171.33547     -171.33547    
Loop time of 123.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.289 hours/ns, 8.101 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.17     | 122.17     | 122.17     |   0.0 | 98.97
Neigh   | 0.64186    | 0.64186    | 0.64186    |   0.0 |  0.52
Comm    | 0.11417    | 0.11417    | 0.11417    |   0.0 |  0.09
Output  | 0.00020517 | 0.00020517 | 0.00020517 |   0.0 |  0.00
Modify  | 0.4483     | 0.4483     | 0.4483     |   0.0 |  0.36
Other   |            | 0.06204    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3757 ave        3757 max        3757 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127164 ave      127164 max      127164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127164
Ave neighs/atom = 63.582
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.56013155356, Press = 0.522801549645566
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -3622.8868     -3622.8868     -3707.7609     -3707.7609      328.47153      328.47153      42204.078      42204.078     -171.33547     -171.33547    
    121000  -3621.3824     -3621.3824     -3709.0799     -3709.0799      339.39843      339.39843      42144.762      42144.762     -111.34268     -111.34268    
Loop time of 120.054 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.81     | 118.81     | 118.81     |   0.0 | 98.96
Neigh   | 0.63472    | 0.63472    | 0.63472    |   0.0 |  0.53
Comm    | 0.11291    | 0.11291    | 0.11291    |   0.0 |  0.09
Output  | 0.00016756 | 0.00016756 | 0.00016756 |   0.0 |  0.00
Modify  | 0.43371    | 0.43371    | 0.43371    |   0.0 |  0.36
Other   |            | 0.06174    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3747 ave        3747 max        3747 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127316 ave      127316 max      127316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127316
Ave neighs/atom = 63.658
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.562853844074, Press = 0.303464648538118
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -3621.3824     -3621.3824     -3709.0799     -3709.0799      339.39843      339.39843      42144.762      42144.762     -111.34268     -111.34268    
    122000  -3625.5597     -3625.5597     -3710.707      -3710.707       329.52869      329.52869      42000.965      42000.965      379.57138      379.57138    
Loop time of 118.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.853 hours/ns, 8.455 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.07     | 117.07     | 117.07     |   0.0 | 98.99
Neigh   | 0.60378    | 0.60378    | 0.60378    |   0.0 |  0.51
Comm    | 0.10994    | 0.10994    | 0.10994    |   0.0 |  0.09
Output  | 0.00016881 | 0.00016881 | 0.00016881 |   0.0 |  0.00
Modify  | 0.42089    | 0.42089    | 0.42089    |   0.0 |  0.36
Other   |            | 0.06069    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3833 ave        3833 max        3833 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127542 ave      127542 max      127542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127542
Ave neighs/atom = 63.771
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.545942166364, Press = 0.273283196232451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -3625.5597     -3625.5597     -3710.707      -3710.707       329.52869      329.52869      42000.965      42000.965      379.57138      379.57138    
    123000  -3621.6929     -3621.6929     -3708.5186     -3708.5186      336.02446      336.02446      41889.17       41889.17       704.55797      704.55797    
Loop time of 123.623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.340 hours/ns, 8.089 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.37     | 122.37     | 122.37     |   0.0 | 98.98
Neigh   | 0.61597    | 0.61597    | 0.61597    |   0.0 |  0.50
Comm    | 0.11731    | 0.11731    | 0.11731    |   0.0 |  0.09
Output  | 0.00016792 | 0.00016792 | 0.00016792 |   0.0 |  0.00
Modify  | 0.46091    | 0.46091    | 0.46091    |   0.0 |  0.37
Other   |            | 0.06178    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3796 ave        3796 max        3796 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127866 ave      127866 max      127866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127866
Ave neighs/atom = 63.933
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.541346622634, Press = 0.34045434863751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -3621.6929     -3621.6929     -3708.5186     -3708.5186      336.02446      336.02446      41889.17       41889.17       704.55797      704.55797    
    124000  -3620.7589     -3620.7589     -3707.9689     -3707.9689      337.51168      337.51168      41938.248      41938.248      730.66487      730.66487    
Loop time of 123.626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.341 hours/ns, 8.089 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.35     | 122.35     | 122.35     |   0.0 | 98.97
Neigh   | 0.64603    | 0.64603    | 0.64603    |   0.0 |  0.52
Comm    | 0.11609    | 0.11609    | 0.11609    |   0.0 |  0.09
Output  | 0.00047823 | 0.00047823 | 0.00047823 |   0.0 |  0.00
Modify  | 0.45403    | 0.45403    | 0.45403    |   0.0 |  0.37
Other   |            | 0.06253    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3787 ave        3787 max        3787 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127940 ave      127940 max      127940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127940
Ave neighs/atom = 63.97
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.518463787056, Press = 0.918519264275678
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -3620.7589     -3620.7589     -3707.9689     -3707.9689      337.51168      337.51168      41938.248      41938.248      730.66487      730.66487    
    125000  -3622.4165     -3622.4165     -3707.6819     -3707.6819      329.9859       329.9859       42278.344      42278.344     -475.07249     -475.07249    
Loop time of 122.221 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.707 ns/day, 33.950 hours/ns, 8.182 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.95     | 120.95     | 120.95     |   0.0 | 98.96
Neigh   | 0.64457    | 0.64457    | 0.64457    |   0.0 |  0.53
Comm    | 0.11506    | 0.11506    | 0.11506    |   0.0 |  0.09
Output  | 0.00020749 | 0.00020749 | 0.00020749 |   0.0 |  0.00
Modify  | 0.44905    | 0.44905    | 0.44905    |   0.0 |  0.37
Other   |            | 0.06233    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3774 ave        3774 max        3774 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127062 ave      127062 max      127062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127062
Ave neighs/atom = 63.531
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.515985236066, Press = 0.548354157477716
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -3622.4165     -3622.4165     -3707.6819     -3707.6819      329.9859       329.9859       42278.344      42278.344     -475.07249     -475.07249    
    126000  -3618.1565     -3618.1565     -3706.3714     -3706.3714      341.4009       341.4009       42311.381      42311.381     -367.89015     -367.89015    
Loop time of 121.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.757 hours/ns, 8.229 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.26     | 120.26     | 120.26     |   0.0 | 98.96
Neigh   | 0.64068    | 0.64068    | 0.64068    |   0.0 |  0.53
Comm    | 0.11365    | 0.11365    | 0.11365    |   0.0 |  0.09
Output  | 0.00021593 | 0.00021593 | 0.00021593 |   0.0 |  0.00
Modify  | 0.44446    | 0.44446    | 0.44446    |   0.0 |  0.37
Other   |            | 0.06298    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3748 ave        3748 max        3748 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126908 ave      126908 max      126908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126908
Ave neighs/atom = 63.454
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.522595302247, Press = 0.250864459558782
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -3618.1565     -3618.1565     -3706.3714     -3706.3714      341.4009       341.4009       42311.381      42311.381     -367.89015     -367.89015    
    127000  -3623.4862     -3623.4862     -3707.7693     -3707.7693      326.18456      326.18456      42156.537      42156.537     -82.691659     -82.691659    
Loop time of 122.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.706 ns/day, 34.003 hours/ns, 8.169 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.17     | 121.17     | 121.17     |   0.0 | 98.99
Neigh   | 0.61623    | 0.61623    | 0.61623    |   0.0 |  0.50
Comm    | 0.1145     | 0.1145     | 0.1145     |   0.0 |  0.09
Output  | 0.00016628 | 0.00016628 | 0.00016628 |   0.0 |  0.00
Modify  | 0.44707    | 0.44707    | 0.44707    |   0.0 |  0.37
Other   |            | 0.06194    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3709 ave        3709 max        3709 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127394 ave      127394 max      127394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127394
Ave neighs/atom = 63.697
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.519113712727, Press = 0.248415754478843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -3623.4862     -3623.4862     -3707.7693     -3707.7693      326.18456      326.18456      42156.537      42156.537     -82.691659     -82.691659    
    128000  -3619.6232     -3619.6232     -3708.9066     -3708.9066      345.53608      345.53608      42108.075      42108.075      243.76648      243.76648    
Loop time of 109.905 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.529 hours/ns, 9.099 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.79     | 108.79     | 108.79     |   0.0 | 98.98
Neigh   | 0.59968    | 0.59968    | 0.59968    |   0.0 |  0.55
Comm    | 0.10024    | 0.10024    | 0.10024    |   0.0 |  0.09
Output  | 0.00016872 | 0.00016872 | 0.00016872 |   0.0 |  0.00
Modify  | 0.3585     | 0.3585     | 0.3585     |   0.0 |  0.33
Other   |            | 0.05698    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3769 ave        3769 max        3769 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127154 ave      127154 max      127154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127154
Ave neighs/atom = 63.577
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.530149454022, Press = -0.0114727754545549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -3619.6232     -3619.6232     -3708.9066     -3708.9066      345.53608      345.53608      42108.075      42108.075      243.76648      243.76648    
    129000  -3620.2571     -3620.2571     -3707.2405     -3707.2405      336.63466      336.63466      41850.221      41850.221      900.7505       900.7505     
Loop time of 112.587 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.274 hours/ns, 8.882 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.44     | 111.44     | 111.44     |   0.0 | 98.98
Neigh   | 0.60572    | 0.60572    | 0.60572    |   0.0 |  0.54
Comm    | 0.10375    | 0.10375    | 0.10375    |   0.0 |  0.09
Output  | 0.00016822 | 0.00016822 | 0.00016822 |   0.0 |  0.00
Modify  | 0.37783    | 0.37783    | 0.37783    |   0.0 |  0.34
Other   |            | 0.05826    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3771 ave        3771 max        3771 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127978 ave      127978 max      127978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.533496613673, Press = 0.507849287439519
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -3620.2571     -3620.2571     -3707.2405     -3707.2405      336.63466      336.63466      41850.221      41850.221      900.7505       900.7505     
    130000  -3620.7365     -3620.7365     -3705.5011     -3705.5011      328.0476       328.0476       41915.865      41915.865      749.78069      749.78069    
Loop time of 124.307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.530 hours/ns, 8.045 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.02     | 123.02     | 123.02     |   0.0 | 98.97
Neigh   | 0.64372    | 0.64372    | 0.64372    |   0.0 |  0.52
Comm    | 0.11759    | 0.11759    | 0.11759    |   0.0 |  0.09
Output  | 0.00016855 | 0.00016855 | 0.00016855 |   0.0 |  0.00
Modify  | 0.45914    | 0.45914    | 0.45914    |   0.0 |  0.37
Other   |            | 0.06209    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3762 ave        3762 max        3762 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128320 ave      128320 max      128320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128320
Ave neighs/atom = 64.16
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.524568788684, Press = 0.696065572401409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -3620.7365     -3620.7365     -3705.5011     -3705.5011      328.0476       328.0476       41915.865      41915.865      749.78069      749.78069    
    131000  -3621.4976     -3621.4976     -3705.5992     -3705.5992      325.48185      325.48185      42195.891      42195.891     -236.20025     -236.20025    
Loop time of 120.667 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.519 hours/ns, 8.287 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.45     | 119.45     | 119.45     |   0.0 | 98.99
Neigh   | 0.60947    | 0.60947    | 0.60947    |   0.0 |  0.51
Comm    | 0.11294    | 0.11294    | 0.11294    |   0.0 |  0.09
Output  | 0.00016986 | 0.00016986 | 0.00016986 |   0.0 |  0.00
Modify  | 0.43644    | 0.43644    | 0.43644    |   0.0 |  0.36
Other   |            | 0.0611     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3775 ave        3775 max        3775 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127598 ave      127598 max      127598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127598
Ave neighs/atom = 63.799
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.522113411715, Press = 0.742730668569354
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -3621.4976     -3621.4976     -3705.5992     -3705.5992      325.48185      325.48185      42195.891      42195.891     -236.20025     -236.20025    
    132000  -3623.7646     -3623.7646     -3709.4315     -3709.4315      331.53953      331.53953      42287.567      42287.567     -615.16615     -615.16615    
Loop time of 123.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.301 hours/ns, 8.098 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.2      | 122.2      | 122.2      |   0.0 | 98.97
Neigh   | 0.64617    | 0.64617    | 0.64617    |   0.0 |  0.52
Comm    | 0.11482    | 0.11482    | 0.11482    |   0.0 |  0.09
Output  | 0.00016917 | 0.00016917 | 0.00016917 |   0.0 |  0.00
Modify  | 0.45361    | 0.45361    | 0.45361    |   0.0 |  0.37
Other   |            | 0.06266    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3753 ave        3753 max        3753 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127146 ave      127146 max      127146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127146
Ave neighs/atom = 63.573
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.507880547746, Press = 0.487327273645245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -3623.7646     -3623.7646     -3709.4315     -3709.4315      331.53953      331.53953      42287.567      42287.567     -615.16615     -615.16615    
    133000  -3623.0978     -3623.0978     -3709.1965     -3709.1965      333.21089      333.21089      42087.849      42087.849      61.686221      61.686221    
Loop time of 113.226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.452 hours/ns, 8.832 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.07     | 112.07     | 112.07     |   0.0 | 98.98
Neigh   | 0.60762    | 0.60762    | 0.60762    |   0.0 |  0.54
Comm    | 0.10521    | 0.10521    | 0.10521    |   0.0 |  0.09
Output  | 0.00016801 | 0.00016801 | 0.00016801 |   0.0 |  0.00
Modify  | 0.38541    | 0.38541    | 0.38541    |   0.0 |  0.34
Other   |            | 0.05755    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3784 ave        3784 max        3784 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127390 ave      127390 max      127390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127390
Ave neighs/atom = 63.695
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.515944443733, Press = 0.114653905529854
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -3623.0978     -3623.0978     -3709.1965     -3709.1965      333.21089      333.21089      42087.849      42087.849      61.686221      61.686221    
    134000  -3618.5351     -3618.5351     -3708.9681     -3708.9681      349.98524      349.98524      42022.886      42022.886      380.81714      380.81714    
Loop time of 122.629 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.705 ns/day, 34.064 hours/ns, 8.155 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.39     | 121.39     | 121.39     |   0.0 | 98.99
Neigh   | 0.61347    | 0.61347    | 0.61347    |   0.0 |  0.50
Comm    | 0.11322    | 0.11322    | 0.11322    |   0.0 |  0.09
Output  | 0.00016947 | 0.00016947 | 0.00016947 |   0.0 |  0.00
Modify  | 0.45175    | 0.45175    | 0.45175    |   0.0 |  0.37
Other   |            | 0.06254    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3750 ave        3750 max        3750 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127530 ave      127530 max      127530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127530
Ave neighs/atom = 63.765
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.527289627205, Press = 0.302293209581217
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -3618.5351     -3618.5351     -3708.9681     -3708.9681      349.98524      349.98524      42022.886      42022.886      380.81714      380.81714    
    135000  -3623.6221     -3623.6221     -3707.5447     -3707.5447      324.78933      324.78933      41973.256      41973.256      505.47143      505.47143    
Loop time of 123.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.187 hours/ns, 8.125 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.81     | 121.81     | 121.81     |   0.0 | 98.97
Neigh   | 0.64025    | 0.64025    | 0.64025    |   0.0 |  0.52
Comm    | 0.11411    | 0.11411    | 0.11411    |   0.0 |  0.09
Output  | 0.00021701 | 0.00021701 | 0.00021701 |   0.0 |  0.00
Modify  | 0.4497     | 0.4497     | 0.4497     |   0.0 |  0.37
Other   |            | 0.06339    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3762 ave        3762 max        3762 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127926 ave      127926 max      127926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.523810039585, Press = 0.674795476068072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -3623.6221     -3623.6221     -3707.5447     -3707.5447      324.78933      324.78933      41973.256      41973.256      505.47143      505.47143    
    136000  -3620.4258     -3620.4258     -3707.1852     -3707.1852      335.76797      335.76797      42186.44       42186.44       3.7871403      3.7871403    
Loop time of 123.062 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.184 hours/ns, 8.126 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.79     | 121.79     | 121.79     |   0.0 | 98.97
Neigh   | 0.64334    | 0.64334    | 0.64334    |   0.0 |  0.52
Comm    | 0.11478    | 0.11478    | 0.11478    |   0.0 |  0.09
Output  | 0.00020232 | 0.00020232 | 0.00020232 |   0.0 |  0.00
Modify  | 0.44938    | 0.44938    | 0.44938    |   0.0 |  0.37
Other   |            | 0.06302    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3730 ave        3730 max        3730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127368 ave      127368 max      127368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127368
Ave neighs/atom = 63.684
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.525868678661, Press = 0.573423331785305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -3620.4258     -3620.4258     -3707.1852     -3707.1852      335.76797      335.76797      42186.44       42186.44       3.7871403      3.7871403    
    137000  -3620.0186     -3620.0186     -3707.1714     -3707.1714      337.29015      337.29015      42205.27       42205.27      -92.150771     -92.150771    
Loop time of 122.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.118 hours/ns, 8.142 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.59     | 121.59     | 121.59     |   0.0 | 98.99
Neigh   | 0.61834    | 0.61834    | 0.61834    |   0.0 |  0.50
Comm    | 0.11259    | 0.11259    | 0.11259    |   0.0 |  0.09
Output  | 0.00020278 | 0.00020278 | 0.00020278 |   0.0 |  0.00
Modify  | 0.44626    | 0.44626    | 0.44626    |   0.0 |  0.36
Other   |            | 0.0631     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3754 ave        3754 max        3754 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127214 ave      127214 max      127214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127214
Ave neighs/atom = 63.607
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.51876689086, Press = 0.496718172301239
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -3620.0186     -3620.0186     -3707.1714     -3707.1714      337.29015      337.29015      42205.27       42205.27      -92.150771     -92.150771    
    138000  -3620.399      -3620.399      -3707.6368     -3707.6368      337.61934      337.61934      42212.016      42212.016     -134.97701     -134.97701    
Loop time of 122.501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.705 ns/day, 34.028 hours/ns, 8.163 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.26     | 121.26     | 121.26     |   0.0 | 98.99
Neigh   | 0.61404    | 0.61404    | 0.61404    |   0.0 |  0.50
Comm    | 0.11375    | 0.11375    | 0.11375    |   0.0 |  0.09
Output  | 0.00020409 | 0.00020409 | 0.00020409 |   0.0 |  0.00
Modify  | 0.45004    | 0.45004    | 0.45004    |   0.0 |  0.37
Other   |            | 0.06356    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3812 ave        3812 max        3812 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127222 ave      127222 max      127222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127222
Ave neighs/atom = 63.611
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.539932624331, Press = 0.338081000416128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -3620.399      -3620.399      -3707.6368     -3707.6368      337.61934      337.61934      42212.016      42212.016     -134.97701     -134.97701    
    139000  -3620.7036     -3620.7036     -3706.5523     -3706.5523      332.24338      332.24338      42162.512      42162.512     -5.5347413     -5.5347413    
Loop time of 109.882 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.523 hours/ns, 9.101 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.8      | 108.8      | 108.8      |   0.0 | 99.01
Neigh   | 0.56972    | 0.56972    | 0.56972    |   0.0 |  0.52
Comm    | 0.10003    | 0.10003    | 0.10003    |   0.0 |  0.09
Output  | 0.00016514 | 0.00016514 | 0.00016514 |   0.0 |  0.00
Modify  | 0.35558    | 0.35558    | 0.35558    |   0.0 |  0.32
Other   |            | 0.05747    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3741 ave        3741 max        3741 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127376 ave      127376 max      127376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127376
Ave neighs/atom = 63.688
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.542098708686, Press = 0.566965445123058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -3620.7036     -3620.7036     -3706.5523     -3706.5523      332.24338      332.24338      42162.512      42162.512     -5.5347413     -5.5347413    
    140000  -3623.0751     -3623.0751     -3710.1205     -3710.1205      336.87462      336.87462      42206.568      42206.568     -285.25642     -285.25642    
Loop time of 109.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.303 hours/ns, 9.167 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.99     | 107.99     | 107.99     |   0.0 | 98.99
Neigh   | 0.59051    | 0.59051    | 0.59051    |   0.0 |  0.54
Comm    | 0.099539   | 0.099539   | 0.099539   |   0.0 |  0.09
Output  | 0.00020785 | 0.00020785 | 0.00020785 |   0.0 |  0.00
Modify  | 0.35079    | 0.35079    | 0.35079    |   0.0 |  0.32
Other   |            | 0.05704    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3781 ave        3781 max        3781 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127128 ave      127128 max      127128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127128
Ave neighs/atom = 63.564
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.545234371013, Press = 0.405649051154802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -3623.0751     -3623.0751     -3710.1205     -3710.1205      336.87462      336.87462      42206.568      42206.568     -285.25642     -285.25642    
    141000  -3619.6608     -3619.6608     -3706.499      -3706.499       336.07307      336.07307      42387.246      42387.246     -771.62103     -771.62103    
Loop time of 109.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.494 hours/ns, 9.109 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.67     | 108.67     | 108.67     |   0.0 | 98.99
Neigh   | 0.59343    | 0.59343    | 0.59343    |   0.0 |  0.54
Comm    | 0.10139    | 0.10139    | 0.10139    |   0.0 |  0.09
Output  | 0.00017189 | 0.00017189 | 0.00017189 |   0.0 |  0.00
Modify  | 0.35986    | 0.35986    | 0.35986    |   0.0 |  0.33
Other   |            | 0.05715    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3738 ave        3738 max        3738 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126978 ave      126978 max      126978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126978
Ave neighs/atom = 63.489
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.552889056123, Press = 0.397821418185211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -3619.6608     -3619.6608     -3706.499      -3706.499       336.07307      336.07307      42387.246      42387.246     -771.62103     -771.62103    
    142000  -3623.9413     -3623.9413     -3710.6462     -3710.6462      335.55687      335.55687      42169.493      42169.493     -175.7628      -175.7628     
Loop time of 123.381 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.273 hours/ns, 8.105 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.13     | 122.13     | 122.13     |   0.0 | 98.99
Neigh   | 0.61933    | 0.61933    | 0.61933    |   0.0 |  0.50
Comm    | 0.11511    | 0.11511    | 0.11511    |   0.0 |  0.09
Output  | 0.00020759 | 0.00020759 | 0.00020759 |   0.0 |  0.00
Modify  | 0.45512    | 0.45512    | 0.45512    |   0.0 |  0.37
Other   |            | 0.06249    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3780 ave        3780 max        3780 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127190 ave      127190 max      127190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127190
Ave neighs/atom = 63.595
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.546368939994, Press = 0.263754995062102
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -3623.9413     -3623.9413     -3710.6462     -3710.6462      335.55687      335.55687      42169.493      42169.493     -175.7628      -175.7628     
    143000  -3618.7964     -3618.7964     -3706.1028     -3706.1028      337.88483      337.88483      42089.253      42089.253      336.40453      336.40453    
Loop time of 123.53 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.314 hours/ns, 8.095 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.26     | 122.26     | 122.26     |   0.0 | 98.97
Neigh   | 0.64601    | 0.64601    | 0.64601    |   0.0 |  0.52
Comm    | 0.11456    | 0.11456    | 0.11456    |   0.0 |  0.09
Output  | 0.0002953  | 0.0002953  | 0.0002953  |   0.0 |  0.00
Modify  | 0.44988    | 0.44988    | 0.44988    |   0.0 |  0.36
Other   |            | 0.06322    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3763 ave        3763 max        3763 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127166 ave      127166 max      127166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127166
Ave neighs/atom = 63.583
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.536955832612, Press = 0.0547169467250903
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -3618.7964     -3618.7964     -3706.1028     -3706.1028      337.88483      337.88483      42089.253      42089.253      336.40453      336.40453    
    144000  -3620.6493     -3620.6493     -3708.1112     -3708.1112      338.48646      338.48646      41831.455      41831.455      968.74479      968.74479    
Loop time of 123.618 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.338 hours/ns, 8.089 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.33     | 122.33     | 122.33     |   0.0 | 98.96
Neigh   | 0.65204    | 0.65204    | 0.65204    |   0.0 |  0.53
Comm    | 0.1166     | 0.1166     | 0.1166     |   0.0 |  0.09
Output  | 0.00020435 | 0.00020435 | 0.00020435 |   0.0 |  0.00
Modify  | 0.45669    | 0.45669    | 0.45669    |   0.0 |  0.37
Other   |            | 0.06247    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3841 ave        3841 max        3841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128104 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.530769162688, Press = 0.519282264568187
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -3620.6493     -3620.6493     -3708.1112     -3708.1112      338.48646      338.48646      41831.455      41831.455      968.74479      968.74479    
    145000  -3625.3088     -3625.3088     -3709.4292     -3709.4292      325.55465      325.55465      42052.424      42052.424      175.61718      175.61718    
Loop time of 123.538 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.316 hours/ns, 8.095 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.24     | 122.24     | 122.24     |   0.0 | 98.95
Neigh   | 0.67162    | 0.67162    | 0.67162    |   0.0 |  0.54
Comm    | 0.11582    | 0.11582    | 0.11582    |   0.0 |  0.09
Output  | 0.00020757 | 0.00020757 | 0.00020757 |   0.0 |  0.00
Modify  | 0.45198    | 0.45198    | 0.45198    |   0.0 |  0.37
Other   |            | 0.06231    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3773 ave        3773 max        3773 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127460 ave      127460 max      127460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127460
Ave neighs/atom = 63.73
Neighbor list builds = 25
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.54231259966, Press = 0.700332051881957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -3625.3088     -3625.3088     -3709.4292     -3709.4292      325.55465      325.55465      42052.424      42052.424      175.61718      175.61718    
    146000  -3623.0902     -3623.0902     -3707.6431     -3707.6431      327.22837      327.22837      42205.191      42205.191     -368.38172     -368.38172    
Loop time of 123.76 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.48     | 122.48     | 122.48     |   0.0 | 98.97
Neigh   | 0.64481    | 0.64481    | 0.64481    |   0.0 |  0.52
Comm    | 0.11609    | 0.11609    | 0.11609    |   0.0 |  0.09
Output  | 0.00020873 | 0.00020873 | 0.00020873 |   0.0 |  0.00
Modify  | 0.456      | 0.456      | 0.456      |   0.0 |  0.37
Other   |            | 0.06146    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3756 ave        3756 max        3756 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127524 ave      127524 max      127524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127524
Ave neighs/atom = 63.762
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.537533400978, Press = 0.221051513082044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    146000  -3623.0902     -3623.0902     -3707.6431     -3707.6431      327.22837      327.22837      42205.191      42205.191     -368.38172     -368.38172    
    147000  -3620.6214     -3620.6214     -3706.2605     -3706.2605      331.4319       331.4319       42179.641      42179.641     -176.864       -176.864      
Loop time of 121.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.693 hours/ns, 8.244 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.07     | 120.07     | 120.07     |   0.0 | 98.99
Neigh   | 0.60913    | 0.60913    | 0.60913    |   0.0 |  0.50
Comm    | 0.11233    | 0.11233    | 0.11233    |   0.0 |  0.09
Output  | 0.00017093 | 0.00017093 | 0.00017093 |   0.0 |  0.00
Modify  | 0.43804    | 0.43804    | 0.43804    |   0.0 |  0.36
Other   |            | 0.06214    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3766 ave        3766 max        3766 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127336 ave      127336 max      127336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127336
Ave neighs/atom = 63.668
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.543222621731, Press = 0.256357763653939
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    147000  -3620.6214     -3620.6214     -3706.2605     -3706.2605      331.4319       331.4319       42179.641      42179.641     -176.864       -176.864      
    148000  -3621.5657     -3621.5657     -3709.159      -3709.159       338.99512      338.99512      42034.761      42034.761      324.99975      324.99975    
Loop time of 118.109 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.732 ns/day, 32.808 hours/ns, 8.467 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.92     | 116.92     | 116.92     |   0.0 | 99.00
Neigh   | 0.599      | 0.599      | 0.599      |   0.0 |  0.51
Comm    | 0.10956    | 0.10956    | 0.10956    |   0.0 |  0.09
Output  | 0.00016808 | 0.00016808 | 0.00016808 |   0.0 |  0.00
Modify  | 0.41688    | 0.41688    | 0.41688    |   0.0 |  0.35
Other   |            | 0.06019    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3805 ave        3805 max        3805 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127740 ave      127740 max      127740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127740
Ave neighs/atom = 63.87
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.550737769703, Press = 0.356627698056718
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    148000  -3621.5657     -3621.5657     -3709.159      -3709.159       338.99512      338.99512      42034.761      42034.761      324.99975      324.99975    
    149000  -3622.545      -3622.545      -3708.9873     -3708.9873      334.5407       334.5407       42022.915      42022.915      442.24101      442.24101    
Loop time of 110.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.785 ns/day, 30.563 hours/ns, 9.089 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.92     | 108.92     | 108.92     |   0.0 | 98.99
Neigh   | 0.59415    | 0.59415    | 0.59415    |   0.0 |  0.54
Comm    | 0.1004     | 0.1004     | 0.1004     |   0.0 |  0.09
Output  | 0.00016721 | 0.00016721 | 0.00016721 |   0.0 |  0.00
Modify  | 0.3597     | 0.3597     | 0.3597     |   0.0 |  0.33
Other   |            | 0.05555    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3763 ave        3763 max        3763 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127604 ave      127604 max      127604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127604
Ave neighs/atom = 63.802
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.545493915351, Press = 0.751593096686703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    149000  -3622.545      -3622.545      -3708.9873     -3708.9873      334.5407       334.5407       42022.915      42022.915      442.24101      442.24101    
    150000  -3621.8682     -3621.8682     -3708.6201     -3708.6201      335.73872      335.73872      42234.351      42234.351     -303.09783     -303.09783    
Loop time of 109.713 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.476 hours/ns, 9.115 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.6      | 108.6      | 108.6      |   0.0 | 98.99
Neigh   | 0.59501    | 0.59501    | 0.59501    |   0.0 |  0.54
Comm    | 0.10021    | 0.10021    | 0.10021    |   0.0 |  0.09
Output  | 0.00016917 | 0.00016917 | 0.00016917 |   0.0 |  0.00
Modify  | 0.35842    | 0.35842    | 0.35842    |   0.0 |  0.33
Other   |            | 0.05624    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3787 ave        3787 max        3787 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127300 ave      127300 max      127300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127300
Ave neighs/atom = 63.65
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.542766646754, Press = 0.710824396742195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    150000  -3621.8682     -3621.8682     -3708.6201     -3708.6201      335.73872      335.73872      42234.351      42234.351     -303.09783     -303.09783    
    151000  -3624.5509     -3624.5509     -3709.4644     -3709.4644      328.62369      328.62369      42249.248      42249.248     -466.21012     -466.21012    
Loop time of 117.741 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.53     | 116.53     | 116.53     |   0.0 | 98.97
Neigh   | 0.62582    | 0.62582    | 0.62582    |   0.0 |  0.53
Comm    | 0.10866    | 0.10866    | 0.10866    |   0.0 |  0.09
Output  | 0.00016948 | 0.00016948 | 0.00016948 |   0.0 |  0.00
Modify  | 0.41444    | 0.41444    | 0.41444    |   0.0 |  0.35
Other   |            | 0.06004    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3727 ave        3727 max        3727 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127176 ave      127176 max      127176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127176
Ave neighs/atom = 63.588
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.524649143695, Press = 0.52625874139953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    151000  -3624.5509     -3624.5509     -3709.4644     -3709.4644      328.62369      328.62369      42249.248      42249.248     -466.21012     -466.21012    
    152000  -3622.378      -3622.378      -3708.5829     -3708.5829      333.62204      333.62204      42211.377      42211.377     -241.46403     -241.46403    
Loop time of 119.513 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.29     | 118.29     | 118.29     |   0.0 | 98.97
Neigh   | 0.62687    | 0.62687    | 0.62687    |   0.0 |  0.52
Comm    | 0.11028    | 0.11028    | 0.11028    |   0.0 |  0.09
Output  | 0.00017105 | 0.00017105 | 0.00017105 |   0.0 |  0.00
Modify  | 0.42762    | 0.42762    | 0.42762    |   0.0 |  0.36
Other   |            | 0.06097    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3778 ave        3778 max        3778 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126786 ave      126786 max      126786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126786
Ave neighs/atom = 63.393
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.519078879175, Press = 0.20862637810143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    152000  -3622.378      -3622.378      -3708.5829     -3708.5829      333.62204      333.62204      42211.377      42211.377     -241.46403     -241.46403    
    153000  -3623.7476     -3623.7476     -3708.824      -3708.824       329.25457      329.25457      42103.648      42103.648      125.25288      125.25288    
Loop time of 109.475 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.410 hours/ns, 9.135 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.37     | 108.37     | 108.37     |   0.0 | 98.99
Neigh   | 0.5909     | 0.5909     | 0.5909     |   0.0 |  0.54
Comm    | 0.099024   | 0.099024   | 0.099024   |   0.0 |  0.09
Output  | 0.00016968 | 0.00016968 | 0.00016968 |   0.0 |  0.00
Modify  | 0.35422    | 0.35422    | 0.35422    |   0.0 |  0.32
Other   |            | 0.05852    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3739 ave        3739 max        3739 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127336 ave      127336 max      127336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127336
Ave neighs/atom = 63.668
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.491113449896, Press = 0.277887056790104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    153000  -3623.7476     -3623.7476     -3708.824      -3708.824       329.25457      329.25457      42103.648      42103.648      125.25288      125.25288    
    154000  -3621.4576     -3621.4576     -3706.214      -3706.214       328.01608      328.01608      42010.665      42010.665      409.96118      409.96118    
Loop time of 109.188 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.330 hours/ns, 9.159 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.09     | 108.09     | 108.09     |   0.0 | 98.99
Neigh   | 0.59046    | 0.59046    | 0.59046    |   0.0 |  0.54
Comm    | 0.098957   | 0.098957   | 0.098957   |   0.0 |  0.09
Output  | 0.00017142 | 0.00017142 | 0.00017142 |   0.0 |  0.00
Modify  | 0.35496    | 0.35496    | 0.35496    |   0.0 |  0.33
Other   |            | 0.05764    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3788 ave        3788 max        3788 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127602 ave      127602 max      127602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127602
Ave neighs/atom = 63.801
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.487296148553, Press = 0.160520474931252
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    154000  -3621.4576     -3621.4576     -3706.214      -3706.214       328.01608      328.01608      42010.665      42010.665      409.96118      409.96118    
    155000  -3616.0915     -3616.0915     -3706.2723     -3706.2723      349.00889      349.00889      42054.407      42054.407      391.00914      391.00914    
Loop time of 109.209 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.336 hours/ns, 9.157 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.11     | 108.11     | 108.11     |   0.0 | 98.99
Neigh   | 0.59147    | 0.59147    | 0.59147    |   0.0 |  0.54
Comm    | 0.099305   | 0.099305   | 0.099305   |   0.0 |  0.09
Output  | 0.00016884 | 0.00016884 | 0.00016884 |   0.0 |  0.00
Modify  | 0.35459    | 0.35459    | 0.35459    |   0.0 |  0.32
Other   |            | 0.05766    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3787 ave        3787 max        3787 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127496 ave      127496 max      127496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127496
Ave neighs/atom = 63.748
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.491601301468, Press = 0.37752833707633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    155000  -3616.0915     -3616.0915     -3706.2723     -3706.2723      349.00889      349.00889      42054.407      42054.407      391.00914      391.00914    
    156000  -3622.4933     -3622.4933     -3708.8513     -3708.8513      334.2147       334.2147       42083.641      42083.641      172.86429      172.86429    
Loop time of 109.462 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.406 hours/ns, 9.136 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.36     | 108.36     | 108.36     |   0.0 | 98.99
Neigh   | 0.59168    | 0.59168    | 0.59168    |   0.0 |  0.54
Comm    | 0.098891   | 0.098891   | 0.098891   |   0.0 |  0.09
Output  | 0.00021413 | 0.00021413 | 0.00021413 |   0.0 |  0.00
Modify  | 0.35414    | 0.35414    | 0.35414    |   0.0 |  0.32
Other   |            | 0.05763    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3737 ave        3737 max        3737 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127642 ave      127642 max      127642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127642
Ave neighs/atom = 63.821
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.481619230203, Press = 0.707260246282354
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    156000  -3622.4933     -3622.4933     -3708.8513     -3708.8513      334.2147       334.2147       42083.641      42083.641      172.86429      172.86429    
    157000  -3625.7719     -3625.7719     -3709.4813     -3709.4813      323.96398      323.96398      42308.564      42308.564     -646.21573     -646.21573    
Loop time of 109.172 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.326 hours/ns, 9.160 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.07     | 108.07     | 108.07     |   0.0 | 98.99
Neigh   | 0.59096    | 0.59096    | 0.59096    |   0.0 |  0.54
Comm    | 0.098999   | 0.098999   | 0.098999   |   0.0 |  0.09
Output  | 0.00016991 | 0.00016991 | 0.00016991 |   0.0 |  0.00
Modify  | 0.35316    | 0.35316    | 0.35316    |   0.0 |  0.32
Other   |            | 0.05748    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3715 ave        3715 max        3715 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127000 ave      127000 max      127000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127000
Ave neighs/atom = 63.5
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.477629195173, Press = 0.416189982713023
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    157000  -3625.7719     -3625.7719     -3709.4813     -3709.4813      323.96398      323.96398      42308.564      42308.564     -646.21573     -646.21573    
    158000  -3622.3899     -3622.3899     -3706.0802     -3706.0802      323.89017      323.89017      42162.407      42162.407     -119.05304     -119.05304    
Loop time of 109.16 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.322 hours/ns, 9.161 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.06     | 108.06     | 108.06     |   0.0 | 98.99
Neigh   | 0.59187    | 0.59187    | 0.59187    |   0.0 |  0.54
Comm    | 0.098695   | 0.098695   | 0.098695   |   0.0 |  0.09
Output  | 0.00017173 | 0.00017173 | 0.00017173 |   0.0 |  0.00
Modify  | 0.35329    | 0.35329    | 0.35329    |   0.0 |  0.32
Other   |            | 0.05745    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3796 ave        3796 max        3796 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127256 ave      127256 max      127256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127256
Ave neighs/atom = 63.628
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.481664522335, Press = 0.144344801633489
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    158000  -3622.3899     -3622.3899     -3706.0802     -3706.0802      323.89017      323.89017      42162.407      42162.407     -119.05304     -119.05304    
    159000  -3619.9844     -3619.9844     -3708.1097     -3708.1097      341.05397      341.05397      42072.393      42072.393      290.50809      290.50809    
Loop time of 109.152 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.320 hours/ns, 9.162 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.03     | 108.03     | 108.03     |   0.0 | 98.97
Neigh   | 0.61566    | 0.61566    | 0.61566    |   0.0 |  0.56
Comm    | 0.09955    | 0.09955    | 0.09955    |   0.0 |  0.09
Output  | 0.0001693  | 0.0001693  | 0.0001693  |   0.0 |  0.00
Modify  | 0.35406    | 0.35406    | 0.35406    |   0.0 |  0.32
Other   |            | 0.05737    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3746 ave        3746 max        3746 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127660 ave      127660 max      127660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127660
Ave neighs/atom = 63.83
Neighbor list builds = 25
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.497759758219, Press = 0.0321651929102679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    159000  -3619.9844     -3619.9844     -3708.1097     -3708.1097      341.05397      341.05397      42072.393      42072.393      290.50809      290.50809    
    160000  -3621.082      -3621.082      -3707.9053     -3707.9053      336.01522      336.01522      41922.767      41922.767      677.46173      677.46173    
Loop time of 109.342 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.373 hours/ns, 9.146 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.24     | 108.24     | 108.24     |   0.0 | 98.99
Neigh   | 0.59158    | 0.59158    | 0.59158    |   0.0 |  0.54
Comm    | 0.098919   | 0.098919   | 0.098919   |   0.0 |  0.09
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.35382    | 0.35382    | 0.35382    |   0.0 |  0.32
Other   |            | 0.05751    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3742 ave        3742 max        3742 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127834 ave      127834 max      127834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127834
Ave neighs/atom = 63.917
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.496439148276, Press = 0.434542113403549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    160000  -3621.082      -3621.082      -3707.9053     -3707.9053      336.01522      336.01522      41922.767      41922.767      677.46173      677.46173    
    161000  -3619.713      -3619.713      -3707.4317     -3707.4317      339.48052      339.48052      42129.254      42129.254     -49.925691     -49.925691    
Loop time of 109.05 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.292 hours/ns, 9.170 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.95     | 107.95     | 107.95     |   0.0 | 98.99
Neigh   | 0.5914     | 0.5914     | 0.5914     |   0.0 |  0.54
Comm    | 0.098209   | 0.098209   | 0.098209   |   0.0 |  0.09
Output  | 0.0001697  | 0.0001697  | 0.0001697  |   0.0 |  0.00
Modify  | 0.35314    | 0.35314    | 0.35314    |   0.0 |  0.32
Other   |            | 0.05701    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3754 ave        3754 max        3754 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127634 ave      127634 max      127634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127634
Ave neighs/atom = 63.817
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.510585425252, Press = 0.517562998757284
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    161000  -3619.713      -3619.713      -3707.4317     -3707.4317      339.48052      339.48052      42129.254      42129.254     -49.925691     -49.925691    
    162000  -3621.6743     -3621.6743     -3707.438      -3707.438       331.91457      331.91457      42149.71       42149.71      -90.957189     -90.957189    
Loop time of 109.19 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.331 hours/ns, 9.158 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.09     | 108.09     | 108.09     |   0.0 | 98.99
Neigh   | 0.59155    | 0.59155    | 0.59155    |   0.0 |  0.54
Comm    | 0.098831   | 0.098831   | 0.098831   |   0.0 |  0.09
Output  | 0.00016909 | 0.00016909 | 0.00016909 |   0.0 |  0.00
Modify  | 0.35333    | 0.35333    | 0.35333    |   0.0 |  0.32
Other   |            | 0.05779    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3730 ave        3730 max        3730 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127462 ave      127462 max      127462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127462
Ave neighs/atom = 63.731
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.504680537189, Press = 0.579308876264724
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    162000  -3621.6743     -3621.6743     -3707.438      -3707.438       331.91457      331.91457      42149.71       42149.71      -90.957189     -90.957189    
    163000  -3625.2781     -3625.2781     -3707.2871     -3707.2871      317.38319      317.38319      42121.243      42121.243      52.956376      52.956376    
Loop time of 109.082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.301 hours/ns, 9.167 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.98     | 107.98     | 107.98     |   0.0 | 98.99
Neigh   | 0.59012    | 0.59012    | 0.59012    |   0.0 |  0.54
Comm    | 0.098675   | 0.098675   | 0.098675   |   0.0 |  0.09
Output  | 0.00020906 | 0.00020906 | 0.00020906 |   0.0 |  0.00
Modify  | 0.353      | 0.353      | 0.353      |   0.0 |  0.32
Other   |            | 0.05747    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3790 ave        3790 max        3790 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127604 ave      127604 max      127604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127604
Ave neighs/atom = 63.802
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.504567117497, Press = 0.349421819401228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    163000  -3625.2781     -3625.2781     -3707.2871     -3707.2871      317.38319      317.38319      42121.243      42121.243      52.956376      52.956376    
    164000  -3621.1234     -3621.1234     -3706.3094     -3706.3094      329.67865      329.67865      42247.433      42247.433     -363.18873     -363.18873    
Loop time of 109.461 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.406 hours/ns, 9.136 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.36     | 108.36     | 108.36     |   0.0 | 98.99
Neigh   | 0.59145    | 0.59145    | 0.59145    |   0.0 |  0.54
Comm    | 0.099215   | 0.099215   | 0.099215   |   0.0 |  0.09
Output  | 0.00021498 | 0.00021498 | 0.00021498 |   0.0 |  0.00
Modify  | 0.35366    | 0.35366    | 0.35366    |   0.0 |  0.32
Other   |            | 0.0578     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3731 ave        3731 max        3731 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127286 ave      127286 max      127286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127286
Ave neighs/atom = 63.643
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.480277267653, Press = 0.397830595022084
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    164000  -3621.1234     -3621.1234     -3706.3094     -3706.3094      329.67865      329.67865      42247.433      42247.433     -363.18873     -363.18873    
    165000  -3624.9411     -3624.9411     -3709.7795     -3709.7795      328.33333      328.33333      42102.843      42102.843     -144.31735     -144.31735    
Loop time of 109.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.370 hours/ns, 9.147 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.23     | 108.23     | 108.23     |   0.0 | 98.99
Neigh   | 0.59014    | 0.59014    | 0.59014    |   0.0 |  0.54
Comm    | 0.098878   | 0.098878   | 0.098878   |   0.0 |  0.09
Output  | 0.00021746 | 0.00021746 | 0.00021746 |   0.0 |  0.00
Modify  | 0.35429    | 0.35429    | 0.35429    |   0.0 |  0.32
Other   |            | 0.05798    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3789 ave        3789 max        3789 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127628 ave      127628 max      127628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127628
Ave neighs/atom = 63.814
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.474867185969, Press = 0.21592504813467
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    165000  -3624.9411     -3624.9411     -3709.7795     -3709.7795      328.33333      328.33333      42102.843      42102.843     -144.31735     -144.31735    
    166000  -3622.2639     -3622.2639     -3709.0384     -3709.0384      335.82624      335.82624      42005.193      42005.193      368.96229      368.96229    
Loop time of 109.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.313 hours/ns, 9.164 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108        | 108        | 108        |   0.0 | 98.97
Neigh   | 0.61521    | 0.61521    | 0.61521    |   0.0 |  0.56
Comm    | 0.098934   | 0.098934   | 0.098934   |   0.0 |  0.09
Output  | 0.00017023 | 0.00017023 | 0.00017023 |   0.0 |  0.00
Modify  | 0.35314    | 0.35314    | 0.35314    |   0.0 |  0.32
Other   |            | 0.05776    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3796 ave        3796 max        3796 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127426 ave      127426 max      127426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127426
Ave neighs/atom = 63.713
Neighbor list builds = 25
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.483092647588, Press = 0.100298251936484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    166000  -3622.2639     -3622.2639     -3709.0384     -3709.0384      335.82624      335.82624      42005.193      42005.193      368.96229      368.96229    
    167000  -3621.3382     -3621.3382     -3710.3971     -3710.3971      344.66716      344.66716      42033.326      42033.326      328.68234      328.68234    
Loop time of 109.415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.393 hours/ns, 9.140 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.31     | 108.31     | 108.31     |   0.0 | 98.99
Neigh   | 0.59061    | 0.59061    | 0.59061    |   0.0 |  0.54
Comm    | 0.09857    | 0.09857    | 0.09857    |   0.0 |  0.09
Output  | 0.00016942 | 0.00016942 | 0.00016942 |   0.0 |  0.00
Modify  | 0.35369    | 0.35369    | 0.35369    |   0.0 |  0.32
Other   |            | 0.05731    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3734 ave        3734 max        3734 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127388 ave      127388 max      127388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127388
Ave neighs/atom = 63.694
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.478598833254, Press = 0.32339530634165
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    167000  -3621.3382     -3621.3382     -3710.3971     -3710.3971      344.66716      344.66716      42033.326      42033.326      328.68234      328.68234    
    168000  -3621.4067     -3621.4067     -3708.8702     -3708.8702      338.49284      338.49284      42070.442      42070.442      218.7896       218.7896     
Loop time of 109.343 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.373 hours/ns, 9.145 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.27     | 108.27     | 108.27     |   0.0 | 99.02
Neigh   | 0.56649    | 0.56649    | 0.56649    |   0.0 |  0.52
Comm    | 0.098482   | 0.098482   | 0.098482   |   0.0 |  0.09
Output  | 0.00016999 | 0.00016999 | 0.00016999 |   0.0 |  0.00
Modify  | 0.35248    | 0.35248    | 0.35248    |   0.0 |  0.32
Other   |            | 0.05724    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3796 ave        3796 max        3796 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127674 ave      127674 max      127674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127674
Ave neighs/atom = 63.837
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.488576030691, Press = 0.7493669012649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    168000  -3621.4067     -3621.4067     -3708.8702     -3708.8702      338.49284      338.49284      42070.442      42070.442      218.7896       218.7896     
    169000  -3621.4645     -3621.4645     -3707.6934     -3707.6934      333.71473      333.71473      42380.01       42380.01      -723.23885     -723.23885    
Loop time of 109.145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.318 hours/ns, 9.162 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.04     | 108.04     | 108.04     |   0.0 | 98.99
Neigh   | 0.5906     | 0.5906     | 0.5906     |   0.0 |  0.54
Comm    | 0.09855    | 0.09855    | 0.09855    |   0.0 |  0.09
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.35376    | 0.35376    | 0.35376    |   0.0 |  0.32
Other   |            | 0.05783    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3735 ave        3735 max        3735 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126940 ave      126940 max      126940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126940
Ave neighs/atom = 63.47
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.4971741163, Press = 0.601208604614367
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    169000  -3621.4645     -3621.4645     -3707.6934     -3707.6934      333.71473      333.71473      42380.01       42380.01      -723.23885     -723.23885    
    170000  -3621.955      -3621.955      -3709.8296     -3709.8296      340.0836       340.0836       42257.008      42257.008     -342.90796     -342.90796    
Loop time of 109.097 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.305 hours/ns, 9.166 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.02     | 108.02     | 108.02     |   0.0 | 99.01
Neigh   | 0.56641    | 0.56641    | 0.56641    |   0.0 |  0.52
Comm    | 0.098551   | 0.098551   | 0.098551   |   0.0 |  0.09
Output  | 0.00016976 | 0.00016976 | 0.00016976 |   0.0 |  0.00
Modify  | 0.35347    | 0.35347    | 0.35347    |   0.0 |  0.32
Other   |            | 0.05794    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3800 ave        3800 max        3800 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127040 ave      127040 max      127040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127040
Ave neighs/atom = 63.52
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.492733616908, Press = 0.243192853686981
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    170000  -3621.955      -3621.955      -3709.8296     -3709.8296      340.0836       340.0836       42257.008      42257.008     -342.90796     -342.90796    
    171000  -3621.8083     -3621.8083     -3709.3827     -3709.3827      338.92188      338.92188      42100.865      42100.865      34.583546      34.583546    
Loop time of 109.238 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.344 hours/ns, 9.154 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.14     | 108.14     | 108.14     |   0.0 | 98.99
Neigh   | 0.59155    | 0.59155    | 0.59155    |   0.0 |  0.54
Comm    | 0.098497   | 0.098497   | 0.098497   |   0.0 |  0.09
Output  | 0.00016945 | 0.00016945 | 0.00016945 |   0.0 |  0.00
Modify  | 0.35421    | 0.35421    | 0.35421    |   0.0 |  0.32
Other   |            | 0.0579     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127388 ave      127388 max      127388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127388
Ave neighs/atom = 63.694
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.491878038338, Press = 0.321749578259333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    171000  -3621.8083     -3621.8083     -3709.3827     -3709.3827      338.92188      338.92188      42100.865      42100.865      34.583546      34.583546    
    172000  -3620.6091     -3620.6091     -3707.2507     -3707.2507      335.31175      335.31175      42158.805      42158.805     -105.37612     -105.37612    
Loop time of 109.13 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.314 hours/ns, 9.163 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.03     | 108.03     | 108.03     |   0.0 | 98.99
Neigh   | 0.59029    | 0.59029    | 0.59029    |   0.0 |  0.54
Comm    | 0.098562   | 0.098562   | 0.098562   |   0.0 |  0.09
Output  | 0.00017112 | 0.00017112 | 0.00017112 |   0.0 |  0.00
Modify  | 0.35293    | 0.35293    | 0.35293    |   0.0 |  0.32
Other   |            | 0.05722    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3746 ave        3746 max        3746 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127638 ave      127638 max      127638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127638
Ave neighs/atom = 63.819
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.488058674913, Press = 0.194948726684591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    172000  -3620.6091     -3620.6091     -3707.2507     -3707.2507      335.31175      335.31175      42158.805      42158.805     -105.37612     -105.37612    
    173000  -3616.8934     -3616.8934     -3706.4631     -3706.4631      346.64393      346.64393      41945.304      41945.304      759.75526      759.75526    
Loop time of 109.319 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.366 hours/ns, 9.148 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.22     | 108.22     | 108.22     |   0.0 | 98.99
Neigh   | 0.59131    | 0.59131    | 0.59131    |   0.0 |  0.54
Comm    | 0.09862    | 0.09862    | 0.09862    |   0.0 |  0.09
Output  | 0.00017014 | 0.00017014 | 0.00017014 |   0.0 |  0.00
Modify  | 0.3545     | 0.3545     | 0.3545     |   0.0 |  0.32
Other   |            | 0.0575     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3796 ave        3796 max        3796 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127656 ave      127656 max      127656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127656
Ave neighs/atom = 63.828
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.485231580127, Press = 0.20204137558294
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    173000  -3616.8934     -3616.8934     -3706.4631     -3706.4631      346.64393      346.64393      41945.304      41945.304      759.75526      759.75526    
    174000  -3621.6278     -3621.6278     -3705.2795     -3705.2795      323.74056      323.74056      42037.06       42037.06       274.73755      274.73755    
Loop time of 109.467 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.407 hours/ns, 9.135 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.36     | 108.36     | 108.36     |   0.0 | 98.99
Neigh   | 0.59207    | 0.59207    | 0.59207    |   0.0 |  0.54
Comm    | 0.098437   | 0.098437   | 0.098437   |   0.0 |  0.09
Output  | 0.00016985 | 0.00016985 | 0.00016985 |   0.0 |  0.00
Modify  | 0.35343    | 0.35343    | 0.35343    |   0.0 |  0.32
Other   |            | 0.05767    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3708 ave        3708 max        3708 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128228 ave      128228 max      128228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128228
Ave neighs/atom = 64.114
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.482465891099, Press = 0.591292831448656
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    174000  -3621.6278     -3621.6278     -3705.2795     -3705.2795      323.74056      323.74056      42037.06       42037.06       274.73755      274.73755    
    175000  -3626.5231     -3626.5231     -3710.5825     -3710.5825      325.31868      325.31868      42122.991      42122.991     -119.20315     -119.20315    
Loop time of 109.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.399 hours/ns, 9.138 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.34     | 108.34     | 108.34     |   0.0 | 98.99
Neigh   | 0.59057    | 0.59057    | 0.59057    |   0.0 |  0.54
Comm    | 0.099498   | 0.099498   | 0.099498   |   0.0 |  0.09
Output  | 0.00016935 | 0.00016935 | 0.00016935 |   0.0 |  0.00
Modify  | 0.35371    | 0.35371    | 0.35371    |   0.0 |  0.32
Other   |            | 0.05705    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3798 ave        3798 max        3798 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127454 ave      127454 max      127454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127454
Ave neighs/atom = 63.727
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.465548371788, Press = 0.50322691666043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    175000  -3626.5231     -3626.5231     -3710.5825     -3710.5825      325.31868      325.31868      42122.991      42122.991     -119.20315     -119.20315    
    176000  -3621.7532     -3621.7532     -3707.4241     -3707.4241      331.55492      331.55492      42206.688      42206.688     -295.65189     -295.65189    
Loop time of 109.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.303 hours/ns, 9.167 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.01     | 108.01     | 108.01     |   0.0 | 99.01
Neigh   | 0.56678    | 0.56678    | 0.56678    |   0.0 |  0.52
Comm    | 0.097988   | 0.097988   | 0.097988   |   0.0 |  0.09
Output  | 0.00016921 | 0.00016921 | 0.00016921 |   0.0 |  0.00
Modify  | 0.35421    | 0.35421    | 0.35421    |   0.0 |  0.32
Other   |            | 0.05821    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3671 ave        3671 max        3671 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127310 ave      127310 max      127310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127310
Ave neighs/atom = 63.655
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.464075188068, Press = 0.154853038724388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    176000  -3621.7532     -3621.7532     -3707.4241     -3707.4241      331.55492      331.55492      42206.688      42206.688     -295.65189     -295.65189    
    177000  -3625.3374     -3625.3374     -3709.5593     -3709.5593      325.94744      325.94744      41902.972      41902.972      624.97571      624.97571    
Loop time of 109.607 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.788 ns/day, 30.446 hours/ns, 9.124 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.51     | 108.51     | 108.51     |   0.0 | 99.00
Neigh   | 0.58994    | 0.58994    | 0.58994    |   0.0 |  0.54
Comm    | 0.098891   | 0.098891   | 0.098891   |   0.0 |  0.09
Output  | 0.00016912 | 0.00016912 | 0.00016912 |   0.0 |  0.00
Modify  | 0.35448    | 0.35448    | 0.35448    |   0.0 |  0.32
Other   |            | 0.05721    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3787 ave        3787 max        3787 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127612 ave      127612 max      127612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127612
Ave neighs/atom = 63.806
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.446512918941, Press = 0.171321397414898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    177000  -3625.3374     -3625.3374     -3709.5593     -3709.5593      325.94744      325.94744      41902.972      41902.972      624.97571      624.97571    
    178000  -3619.7128     -3619.7128     -3706.6169     -3706.6169      336.32771      336.32771      41983.655      41983.655      462.3811       462.3811     
Loop time of 109.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.390 hours/ns, 9.140 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.3      | 108.3      | 108.3      |   0.0 | 98.99
Neigh   | 0.59062    | 0.59062    | 0.59062    |   0.0 |  0.54
Comm    | 0.099036   | 0.099036   | 0.099036   |   0.0 |  0.09
Output  | 0.00021243 | 0.00021243 | 0.00021243 |   0.0 |  0.00
Modify  | 0.35366    | 0.35366    | 0.35366    |   0.0 |  0.32
Other   |            | 0.05739    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3726 ave        3726 max        3726 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127866 ave      127866 max      127866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127866
Ave neighs/atom = 63.933
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.444535860305, Press = 0.508693745777946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    178000  -3619.7128     -3619.7128     -3706.6169     -3706.6169      336.32771      336.32771      41983.655      41983.655      462.3811       462.3811     
    179000  -3617.7743     -3617.7743     -3710.3048     -3710.3048      358.1027       358.1027       42250.727      42250.727     -360.27252     -360.27252    
Loop time of 109.304 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.362 hours/ns, 9.149 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.2      | 108.2      | 108.2      |   0.0 | 98.99
Neigh   | 0.59179    | 0.59179    | 0.59179    |   0.0 |  0.54
Comm    | 0.098499   | 0.098499   | 0.098499   |   0.0 |  0.09
Output  | 0.0001691  | 0.0001691  | 0.0001691  |   0.0 |  0.00
Modify  | 0.35274    | 0.35274    | 0.35274    |   0.0 |  0.32
Other   |            | 0.05723    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3762 ave        3762 max        3762 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127764 ave      127764 max      127764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127764
Ave neighs/atom = 63.882
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.447207807535, Press = 0.718198528106472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    179000  -3617.7743     -3617.7743     -3710.3048     -3710.3048      358.1027       358.1027       42250.727      42250.727     -360.27252     -360.27252    
    180000  -3624.733      -3624.733      -3710.0945     -3710.0945      330.35787      330.35787      42235.029      42235.029     -496.59973     -496.59973    
Loop time of 109.24 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.344 hours/ns, 9.154 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.14     | 108.14     | 108.14     |   0.0 | 98.99
Neigh   | 0.59088    | 0.59088    | 0.59088    |   0.0 |  0.54
Comm    | 0.09882    | 0.09882    | 0.09882    |   0.0 |  0.09
Output  | 0.00017013 | 0.00017013 | 0.00017013 |   0.0 |  0.00
Modify  | 0.35364    | 0.35364    | 0.35364    |   0.0 |  0.32
Other   |            | 0.05821    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3772 ave        3772 max        3772 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127222 ave      127222 max      127222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127222
Ave neighs/atom = 63.611
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.447119560986, Press = 0.382530641431621
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    180000  -3624.733      -3624.733      -3710.0945     -3710.0945      330.35787      330.35787      42235.029      42235.029     -496.59973     -496.59973    
    181000  -3620.1607     -3620.1607     -3706.8759     -3706.8759      335.59707      335.59707      42140.696      42140.696     -9.9102072     -9.9102072    
Loop time of 109.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.316 hours/ns, 9.163 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.06     | 108.06     | 108.06     |   0.0 | 99.01
Neigh   | 0.56628    | 0.56628    | 0.56628    |   0.0 |  0.52
Comm    | 0.098516   | 0.098516   | 0.098516   |   0.0 |  0.09
Output  | 0.00021065 | 0.00021065 | 0.00021065 |   0.0 |  0.00
Modify  | 0.35296    | 0.35296    | 0.35296    |   0.0 |  0.32
Other   |            | 0.05738    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3728 ave        3728 max        3728 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127696 ave      127696 max      127696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127696
Ave neighs/atom = 63.848
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.444101331782, Press = 0.22547719090862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    181000  -3620.1607     -3620.1607     -3706.8759     -3706.8759      335.59707      335.59707      42140.696      42140.696     -9.9102072     -9.9102072    
    182000  -3624.4132     -3624.4132     -3708.6977     -3708.6977      326.18967      326.18967      41991.235      41991.235      311.69735      311.69735    
Loop time of 109.237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.344 hours/ns, 9.154 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.13     | 108.13     | 108.13     |   0.0 | 98.99
Neigh   | 0.59166    | 0.59166    | 0.59166    |   0.0 |  0.54
Comm    | 0.098202   | 0.098202   | 0.098202   |   0.0 |  0.09
Output  | 0.00016923 | 0.00016923 | 0.00016923 |   0.0 |  0.00
Modify  | 0.35497    | 0.35497    | 0.35497    |   0.0 |  0.32
Other   |            | 0.05777    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3742 ave        3742 max        3742 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127934 ave      127934 max      127934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.441974771533, Press = 0.304160413740337
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    182000  -3624.4132     -3624.4132     -3708.6977     -3708.6977      326.18967      326.18967      41991.235      41991.235      311.69735      311.69735    
    183000  -3621.1379     -3621.1379     -3709.4351     -3709.4351      341.71936      341.71936      42118.547      42118.547      31.736117      31.736117    
Loop time of 109.258 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.349 hours/ns, 9.153 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.18     | 108.18     | 108.18     |   0.0 | 99.01
Neigh   | 0.56706    | 0.56706    | 0.56706    |   0.0 |  0.52
Comm    | 0.097592   | 0.097592   | 0.097592   |   0.0 |  0.09
Output  | 0.00016949 | 0.00016949 | 0.00016949 |   0.0 |  0.00
Modify  | 0.35422    | 0.35422    | 0.35422    |   0.0 |  0.32
Other   |            | 0.05743    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3699 ave        3699 max        3699 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127652 ave      127652 max      127652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127652
Ave neighs/atom = 63.826
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.443103772489, Press = 0.229898254189413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    183000  -3621.1379     -3621.1379     -3709.4351     -3709.4351      341.71936      341.71936      42118.547      42118.547      31.736117      31.736117    
    184000  -3622.6862     -3622.6862     -3706.4681     -3706.4681      324.24473      324.24473      42149.593      42149.593     -94.696873     -94.696873    
Loop time of 109.249 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.347 hours/ns, 9.153 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.17     | 108.17     | 108.17     |   0.0 | 99.01
Neigh   | 0.56675    | 0.56675    | 0.56675    |   0.0 |  0.52
Comm    | 0.098541   | 0.098541   | 0.098541   |   0.0 |  0.09
Output  | 0.00021166 | 0.00021166 | 0.00021166 |   0.0 |  0.00
Modify  | 0.35273    | 0.35273    | 0.35273    |   0.0 |  0.32
Other   |            | 0.058      |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3740 ave        3740 max        3740 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127528 ave      127528 max      127528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127528
Ave neighs/atom = 63.764
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.423202015498, Press = 0.178655807248147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    184000  -3622.6862     -3622.6862     -3706.4681     -3706.4681      324.24473      324.24473      42149.593      42149.593     -94.696873     -94.696873    
    185000  -3623.9325     -3623.9325     -3708.8325     -3708.8325      328.57148      328.57148      41970.841      41970.841      476.22999      476.22999    
Loop time of 109.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.370 hours/ns, 9.146 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.23     | 108.23     | 108.23     |   0.0 | 98.99
Neigh   | 0.59076    | 0.59076    | 0.59076    |   0.0 |  0.54
Comm    | 0.098379   | 0.098379   | 0.098379   |   0.0 |  0.09
Output  | 0.00016984 | 0.00016984 | 0.00016984 |   0.0 |  0.00
Modify  | 0.35372    | 0.35372    | 0.35372    |   0.0 |  0.32
Other   |            | 0.05727    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3739 ave        3739 max        3739 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127608 ave      127608 max      127608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127608
Ave neighs/atom = 63.804
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.41661657985, Press = 0.149869060079271
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    185000  -3623.9325     -3623.9325     -3708.8325     -3708.8325      328.57148      328.57148      41970.841      41970.841      476.22999      476.22999    
    186000  -3622.6266     -3622.6266     -3710.5366     -3710.5366      340.22072      340.22072      41868.391      41868.391      868.08978      868.08978    
Loop time of 109.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.418 hours/ns, 9.132 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.43     | 108.43     | 108.43     |   0.0 | 99.02
Neigh   | 0.56625    | 0.56625    | 0.56625    |   0.0 |  0.52
Comm    | 0.098933   | 0.098933   | 0.098933   |   0.0 |  0.09
Output  | 0.00016966 | 0.00016966 | 0.00016966 |   0.0 |  0.00
Modify  | 0.35339    | 0.35339    | 0.35339    |   0.0 |  0.32
Other   |            | 0.0575     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3806 ave        3806 max        3806 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127902 ave      127902 max      127902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127902
Ave neighs/atom = 63.951
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.401590464911, Press = 0.374973772982571
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    186000  -3622.6266     -3622.6266     -3710.5366     -3710.5366      340.22072      340.22072      41868.391      41868.391      868.08978      868.08978    
    187000  -3622.8993     -3622.8993     -3708.121      -3708.121       329.81668      329.81668      42117.607      42117.607     -12.756696     -12.756696    
Loop time of 109.17 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.325 hours/ns, 9.160 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.07     | 108.07     | 108.07     |   0.0 | 98.99
Neigh   | 0.591      | 0.591      | 0.591      |   0.0 |  0.54
Comm    | 0.099146   | 0.099146   | 0.099146   |   0.0 |  0.09
Output  | 0.00016925 | 0.00016925 | 0.00016925 |   0.0 |  0.00
Modify  | 0.35358    | 0.35358    | 0.35358    |   0.0 |  0.32
Other   |            | 0.05736    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3751 ave        3751 max        3751 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127570 ave      127570 max      127570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127570
Ave neighs/atom = 63.785
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.409582397621, Press = 0.45205554886931
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    187000  -3622.8993     -3622.8993     -3708.121      -3708.121       329.81668      329.81668      42117.607      42117.607     -12.756696     -12.756696    
    188000  -3621.5085     -3621.5085     -3707.922      -3707.922       334.42914      334.42914      42273.107      42273.107     -356.54462     -356.54462    
Loop time of 109.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.391 hours/ns, 9.140 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.33     | 108.33     | 108.33     |   0.0 | 99.02
Neigh   | 0.56561    | 0.56561    | 0.56561    |   0.0 |  0.52
Comm    | 0.097653   | 0.097653   | 0.097653   |   0.0 |  0.09
Output  | 0.00016833 | 0.00016833 | 0.00016833 |   0.0 |  0.00
Modify  | 0.35343    | 0.35343    | 0.35343    |   0.0 |  0.32
Other   |            | 0.05802    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3776 ave        3776 max        3776 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127126 ave      127126 max      127126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127126
Ave neighs/atom = 63.563
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.390048332285, Press = 0.375979449924514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    188000  -3621.5085     -3621.5085     -3707.922      -3707.922       334.42914      334.42914      42273.107      42273.107     -356.54462     -356.54462    
    189000  -3623.9365     -3623.9365     -3710.0137     -3710.0137      333.12793      333.12793      42124.322      42124.322     -117.71947     -117.71947    
Loop time of 109.289 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.358 hours/ns, 9.150 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.21     | 108.21     | 108.21     |   0.0 | 99.01
Neigh   | 0.56681    | 0.56681    | 0.56681    |   0.0 |  0.52
Comm    | 0.097813   | 0.097813   | 0.097813   |   0.0 |  0.09
Output  | 0.00016945 | 0.00016945 | 0.00016945 |   0.0 |  0.00
Modify  | 0.35399    | 0.35399    | 0.35399    |   0.0 |  0.32
Other   |            | 0.05786    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3721 ave        3721 max        3721 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127602 ave      127602 max      127602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127602
Ave neighs/atom = 63.801
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.385278635539, Press = 0.168656664880121
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    189000  -3623.9365     -3623.9365     -3710.0137     -3710.0137      333.12793      333.12793      42124.322      42124.322     -117.71947     -117.71947    
    190000  -3621.9983     -3621.9983     -3708.4066     -3708.4066      334.40929      334.40929      42101.815      42101.815      59.369135      59.369135    
Loop time of 109.467 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.407 hours/ns, 9.135 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.39     | 108.39     | 108.39     |   0.0 | 99.02
Neigh   | 0.56671    | 0.56671    | 0.56671    |   0.0 |  0.52
Comm    | 0.09835    | 0.09835    | 0.09835    |   0.0 |  0.09
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.35401    | 0.35401    | 0.35401    |   0.0 |  0.32
Other   |            | 0.05781    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3763 ave        3763 max        3763 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127714 ave      127714 max      127714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127714
Ave neighs/atom = 63.857
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.365357798437, Press = 0.353485362666185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    190000  -3621.9983     -3621.9983     -3708.4066     -3708.4066      334.40929      334.40929      42101.815      42101.815      59.369135      59.369135    
    191000  -3622.6328     -3622.6328     -3709.8108     -3709.8108      337.38808      337.38808      42075.69       42075.69       156.092        156.092      
Loop time of 109.28 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.356 hours/ns, 9.151 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.2      | 108.2      | 108.2      |   0.0 | 99.01
Neigh   | 0.56718    | 0.56718    | 0.56718    |   0.0 |  0.52
Comm    | 0.098068   | 0.098068   | 0.098068   |   0.0 |  0.09
Output  | 0.00017161 | 0.00017161 | 0.00017161 |   0.0 |  0.00
Modify  | 0.35447    | 0.35447    | 0.35447    |   0.0 |  0.32
Other   |            | 0.05797    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3734 ave        3734 max        3734 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127346 ave      127346 max      127346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127346
Ave neighs/atom = 63.673
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.359021539969, Press = 0.281281592197704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    191000  -3622.6328     -3622.6328     -3709.8108     -3709.8108      337.38808      337.38808      42075.69       42075.69       156.092        156.092      
    192000  -3621.7177     -3621.7177     -3708.2877     -3708.2877      335.03481      335.03481      42169.59       42169.59      -64.225118     -64.225118    
Loop time of 109.42 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.394 hours/ns, 9.139 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.34     | 108.34     | 108.34     |   0.0 | 99.02
Neigh   | 0.56745    | 0.56745    | 0.56745    |   0.0 |  0.52
Comm    | 0.098327   | 0.098327   | 0.098327   |   0.0 |  0.09
Output  | 0.00017087 | 0.00017087 | 0.00017087 |   0.0 |  0.00
Modify  | 0.35369    | 0.35369    | 0.35369    |   0.0 |  0.32
Other   |            | 0.05785    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3756 ave        3756 max        3756 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127280 ave      127280 max      127280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127280
Ave neighs/atom = 63.64
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.3414054647, Press = 0.409047867466999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    192000  -3621.7177     -3621.7177     -3708.2877     -3708.2877      335.03481      335.03481      42169.59       42169.59      -64.225118     -64.225118    
    193000  -3621.7703     -3621.7703     -3708.5446     -3708.5446      335.8255       335.8255       42147.754      42147.754     -98.161883     -98.161883    
Loop time of 109.15 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.792 ns/day, 30.319 hours/ns, 9.162 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.07     | 108.07     | 108.07     |   0.0 | 99.01
Neigh   | 0.56726    | 0.56726    | 0.56726    |   0.0 |  0.52
Comm    | 0.097955   | 0.097955   | 0.097955   |   0.0 |  0.09
Output  | 0.00016896 | 0.00016896 | 0.00016896 |   0.0 |  0.00
Modify  | 0.35479    | 0.35479    | 0.35479    |   0.0 |  0.33
Other   |            | 0.05748    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3713 ave        3713 max        3713 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127414 ave      127414 max      127414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127414
Ave neighs/atom = 63.707
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.338592222974, Press = 0.227023915904473
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    193000  -3621.7703     -3621.7703     -3708.5446     -3708.5446      335.8255       335.8255       42147.754      42147.754     -98.161883     -98.161883    
    194000  -3623.4224     -3623.4224     -3708.7106     -3708.7106      330.07443      330.07443      42050.141      42050.141      132.64271      132.64271    
Loop time of 109.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.368 hours/ns, 9.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.25     | 108.25     | 108.25     |   0.0 | 99.01
Neigh   | 0.56654    | 0.56654    | 0.56654    |   0.0 |  0.52
Comm    | 0.09891    | 0.09891    | 0.09891    |   0.0 |  0.09
Output  | 0.00023686 | 0.00023686 | 0.00023686 |   0.0 |  0.00
Modify  | 0.35356    | 0.35356    | 0.35356    |   0.0 |  0.32
Other   |            | 0.05774    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3731 ave        3731 max        3731 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127470 ave      127470 max      127470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127470
Ave neighs/atom = 63.735
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.328539267919, Press = 0.299192501028292
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    194000  -3623.4224     -3623.4224     -3708.7106     -3708.7106      330.07443      330.07443      42050.141      42050.141      132.64271      132.64271    
    195000  -3620.1719     -3620.1719     -3707.1932     -3707.1932      336.78136      336.78136      42187.113      42187.113     -169.84789     -169.84789    
Loop time of 109.287 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.357 hours/ns, 9.150 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.21     | 108.21     | 108.21     |   0.0 | 99.01
Neigh   | 0.56843    | 0.56843    | 0.56843    |   0.0 |  0.52
Comm    | 0.098033   | 0.098033   | 0.098033   |   0.0 |  0.09
Output  | 0.00016934 | 0.00016934 | 0.00016934 |   0.0 |  0.00
Modify  | 0.35328    | 0.35328    | 0.35328    |   0.0 |  0.32
Other   |            | 0.05768    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3794 ave        3794 max        3794 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127620 ave      127620 max      127620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127620
Ave neighs/atom = 63.81
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.318415457577, Press = 0.283524734284875
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    195000  -3620.1719     -3620.1719     -3707.1932     -3707.1932      336.78136      336.78136      42187.113      42187.113     -169.84789     -169.84789    
    196000  -3623.7617     -3623.7617     -3706.6393     -3706.6393      320.74498      320.74498      42296.622      42296.622     -542.61593     -542.61593    
Loop time of 109.325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.368 hours/ns, 9.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.22     | 108.22     | 108.22     |   0.0 | 98.99
Neigh   | 0.59147    | 0.59147    | 0.59147    |   0.0 |  0.54
Comm    | 0.09872    | 0.09872    | 0.09872    |   0.0 |  0.09
Output  | 0.00021149 | 0.00021149 | 0.00021149 |   0.0 |  0.00
Modify  | 0.3537     | 0.3537     | 0.3537     |   0.0 |  0.32
Other   |            | 0.05789    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3657 ave        3657 max        3657 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127446 ave      127446 max      127446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127446
Ave neighs/atom = 63.723
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.305065925295, Press = 0.236071945842674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    196000  -3623.7617     -3623.7617     -3706.6393     -3706.6393      320.74498      320.74498      42296.622      42296.622     -542.61593     -542.61593    
    197000  -3618.9071     -3618.9071     -3707.6771     -3707.6771      343.54918      343.54918      42231.33       42231.33      -268.77434     -268.77434    
Loop time of 109.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.791 ns/day, 30.329 hours/ns, 9.159 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.11     | 108.11     | 108.11     |   0.0 | 99.01
Neigh   | 0.56671    | 0.56671    | 0.56671    |   0.0 |  0.52
Comm    | 0.098106   | 0.098106   | 0.098106   |   0.0 |  0.09
Output  | 0.00021027 | 0.00021027 | 0.00021027 |   0.0 |  0.00
Modify  | 0.35559    | 0.35559    | 0.35559    |   0.0 |  0.33
Other   |            | 0.05771    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3719 ave        3719 max        3719 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127094 ave      127094 max      127094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0