# 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.146558970212937*${_u_distance}
variable latticeconst_converted equal 3.146558970212937*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.14655897021294
Lattice spacing in x,y,z = 3.146559 3.146559 3.146559
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (31.46559 31.46559 31.46559)
  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 (31.46559 31.46559 31.46559)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Mo

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

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


mass          1 ${mass_converted}
mass          1 95.94

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31153.5559995522 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_831380044253_002#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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13549.42      -13549.42      -13620         -13620          273.15         273.15         31153.556      31153.556      2419.8511      2419.8511    
      1000  -13477.19      -13477.19      -13555.159     -13555.159      301.74636      301.74636      31261.825      31261.825      2457.9557      2457.9557    
Loop time of 121.227 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.674 hours/ns, 8.249 timesteps/s
100.0% 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.69     | 120.69     | 120.69     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10104    | 0.10104    | 0.10104    |   0.0 |  0.08
Output  | 0.00026956 | 0.00026956 | 0.00026956 |   0.0 |  0.00
Modify  | 0.37323    | 0.37323    | 0.37323    |   0.0 |  0.31
Other   |            | 0.06106    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13477.19      -13477.19      -13555.159     -13555.159      301.74636      301.74636      31261.825      31261.825      2457.9557      2457.9557    
      2000  -13475.798     -13475.798     -13547.037     -13547.037      275.70329      275.70329      31271.943      31271.943      2975.2505      2975.2505    
Loop time of 125.644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.901 hours/ns, 7.959 timesteps/s
100.0% 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.09     | 125.09     | 125.09     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1038     | 0.1038     | 0.1038     |   0.0 |  0.08
Output  | 0.00023962 | 0.00023962 | 0.00023962 |   0.0 |  0.00
Modify  | 0.38686    | 0.38686    | 0.38686    |   0.0 |  0.31
Other   |            | 0.06374    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13475.798     -13475.798     -13547.037     -13547.037      275.70329      275.70329      31271.943      31271.943      2975.2505      2975.2505    
      3000  -13478.957     -13478.957     -13547.341     -13547.341      264.65222      264.65222      31278.949      31278.949      1881.6007      1881.6007    
Loop time of 118.691 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.728 ns/day, 32.970 hours/ns, 8.425 timesteps/s
100.0% 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.18     | 118.18     | 118.18     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097358   | 0.097358   | 0.097358   |   0.0 |  0.08
Output  | 0.00020333 | 0.00020333 | 0.00020333 |   0.0 |  0.00
Modify  | 0.3566     | 0.3566     | 0.3566     |   0.0 |  0.30
Other   |            | 0.06002    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13478.957     -13478.957     -13547.341     -13547.341      264.65222      264.65222      31278.949      31278.949      1881.6007      1881.6007    
      4000  -13475.231     -13475.231     -13545.016     -13545.016      270.07625      270.07625      31291.288      31291.288      1163.3194      1163.3194    
Loop time of 117.079 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.738 ns/day, 32.522 hours/ns, 8.541 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.58     | 116.58     | 116.58     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096139   | 0.096139   | 0.096139   |   0.0 |  0.08
Output  | 0.00024411 | 0.00024411 | 0.00024411 |   0.0 |  0.00
Modify  | 0.34771    | 0.34771    | 0.34771    |   0.0 |  0.30
Other   |            | 0.05967    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13475.231     -13475.231     -13545.016     -13545.016      270.07625      270.07625      31291.288      31291.288      1163.3194      1163.3194    
      5000  -13479.371     -13479.371     -13546.566     -13546.566      260.05428      260.05428      31287.275      31287.275      953.3978       953.3978     
Loop time of 121.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.866 hours/ns, 8.202 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.38     | 121.38     | 121.38     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10044    | 0.10044    | 0.10044    |   0.0 |  0.08
Output  | 0.00022179 | 0.00022179 | 0.00022179 |   0.0 |  0.00
Modify  | 0.37379    | 0.37379    | 0.37379    |   0.0 |  0.31
Other   |            | 0.06316    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.445955109754, Press = -18.3822227806948
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13479.371     -13479.371     -13546.566     -13546.566      260.05428      260.05428      31287.275      31287.275      953.3978       953.3978     
      6000  -13475.5       -13475.5       -13549.993     -13549.993      288.29517      288.29517      31283.443      31283.443      1266.9396      1266.9396    
Loop time of 127.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.293 hours/ns, 7.871 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.47     | 126.47     | 126.47     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10385    | 0.10385    | 0.10385    |   0.0 |  0.08
Output  | 0.00023446 | 0.00023446 | 0.00023446 |   0.0 |  0.00
Modify  | 0.4127     | 0.4127     | 0.4127     |   0.0 |  0.32
Other   |            | 0.06347    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.641696436865, Press = 18.4354228682279
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13475.5       -13475.5       -13549.993     -13549.993      288.29517      288.29517      31283.443      31283.443      1266.9396      1266.9396    
      7000  -13477.173     -13477.173     -13546.591     -13546.591      268.65235      268.65235      31293.197      31293.197      751.96948      751.96948    
Loop time of 134.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.243 hours/ns, 7.459 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.45     | 133.45     | 133.45     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10793    | 0.10793    | 0.10793    |   0.0 |  0.08
Output  | 0.00020077 | 0.00020077 | 0.00020077 |   0.0 |  0.00
Modify  | 0.44807    | 0.44807    | 0.44807    |   0.0 |  0.33
Other   |            | 0.06599    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.731179503017, Press = 13.1485303425917
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13477.173     -13477.173     -13546.591     -13546.591      268.65235      268.65235      31293.197      31293.197      751.96948      751.96948    
      8000  -13478.967     -13478.967     -13548.386     -13548.386      268.65924      268.65924      31299.855      31299.855      15.118985      15.118985    
Loop time of 135.031 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.640 ns/day, 37.509 hours/ns, 7.406 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.41     | 134.41     | 134.41     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10844    | 0.10844    | 0.10844    |   0.0 |  0.08
Output  | 0.00017289 | 0.00017289 | 0.00017289 |   0.0 |  0.00
Modify  | 0.44926    | 0.44926    | 0.44926    |   0.0 |  0.33
Other   |            | 0.06653    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.476575346094, Press = -1.37981795908178
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13478.967     -13478.967     -13548.386     -13548.386      268.65924      268.65924      31299.855      31299.855      15.118985      15.118985    
      9000  -13476.952     -13476.952     -13547.141     -13547.141      271.63821      271.63821      31308.086      31308.086     -370.17194     -370.17194    
Loop time of 134.184 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.273 hours/ns, 7.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.56     | 133.56     | 133.56     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10911    | 0.10911    | 0.10911    |   0.0 |  0.08
Output  | 0.00019877 | 0.00019877 | 0.00019877 |   0.0 |  0.00
Modify  | 0.44919    | 0.44919    | 0.44919    |   0.0 |  0.33
Other   |            | 0.06609    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.328483715644, Press = -2.69271454214933
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13476.952     -13476.952     -13547.141     -13547.141      271.63821      271.63821      31308.086      31308.086     -370.17194     -370.17194    
     10000  -13481.877     -13481.877     -13549.931     -13549.931      263.37523      263.37523      31301.586      31301.586     -275.0226      -275.0226     
Loop time of 133.61 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.114 hours/ns, 7.484 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.99     | 132.99     | 132.99     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10903    | 0.10903    | 0.10903    |   0.0 |  0.08
Output  | 0.00020822 | 0.00020822 | 0.00020822 |   0.0 |  0.00
Modify  | 0.44861    | 0.44861    | 0.44861    |   0.0 |  0.34
Other   |            | 0.06657    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.177103386808, Press = -4.38544186151462
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13481.877     -13481.877     -13549.931     -13549.931      263.37523      263.37523      31301.586      31301.586     -275.0226      -275.0226     
     11000  -13477.232     -13477.232     -13548.744     -13548.744      276.75716      276.75716      31307.473      31307.473     -618.37362     -618.37362    
Loop time of 121.72 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.17     | 121.17     | 121.17     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099612   | 0.099612   | 0.099612   |   0.0 |  0.08
Output  | 0.00021097 | 0.00021097 | 0.00021097 |   0.0 |  0.00
Modify  | 0.3895     | 0.3895     | 0.3895     |   0.0 |  0.32
Other   |            | 0.06019    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.022603878733, Press = -2.46427862706734
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13477.232     -13477.232     -13548.744     -13548.744      276.75716      276.75716      31307.473      31307.473     -618.37362     -618.37362    
     12000  -13477.33      -13477.33      -13547.551     -13547.551      271.76204      271.76204      31317.401      31317.401     -1226.752      -1226.752     
Loop time of 126.727 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.15     | 126.15     | 126.15     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10311    | 0.10311    | 0.10311    |   0.0 |  0.08
Output  | 0.00016706 | 0.00016706 | 0.00016706 |   0.0 |  0.00
Modify  | 0.41395    | 0.41395    | 0.41395    |   0.0 |  0.33
Other   |            | 0.06255    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.310572854417, Press = -1.64646198465675
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13477.33      -13477.33      -13547.551     -13547.551      271.76204      271.76204      31317.401      31317.401     -1226.752      -1226.752     
     13000  -13477.029     -13477.029     -13548.021     -13548.021      274.74977      274.74977      31340.137      31340.137     -3326.7848     -3326.7848    
Loop time of 129.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 36.004 hours/ns, 7.715 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.02     | 129.02     | 129.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10539    | 0.10539    | 0.10539    |   0.0 |  0.08
Output  | 0.00027216 | 0.00027216 | 0.00027216 |   0.0 |  0.00
Modify  | 0.42581    | 0.42581    | 0.42581    |   0.0 |  0.33
Other   |            | 0.06416    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.365041777003, Press = -2.5026459205722
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13477.029     -13477.029     -13548.021     -13548.021      274.74977      274.74977      31340.137      31340.137     -3326.7848     -3326.7848    
     14000  -13479.498     -13479.498     -13548.388     -13548.388      266.61248      266.61248      31342.802      31342.802     -3703.8489     -3703.8489    
Loop time of 126.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.105 hours/ns, 7.913 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.8      | 125.8      | 125.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10379    | 0.10379    | 0.10379    |   0.0 |  0.08
Output  | 0.00016655 | 0.00016655 | 0.00016655 |   0.0 |  0.00
Modify  | 0.41369    | 0.41369    | 0.41369    |   0.0 |  0.33
Other   |            | 0.06323    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.270350024224, Press = -4.61944098791909
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13479.498     -13479.498     -13548.388     -13548.388      266.61248      266.61248      31342.802      31342.802     -3703.8489     -3703.8489    
     15000  -13475.115     -13475.115     -13547.333     -13547.333      279.48938      279.48938      31320.031      31320.031     -1426.5316     -1426.5316    
Loop time of 134.507 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.642 ns/day, 37.363 hours/ns, 7.435 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.88     | 133.88     | 133.88     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10927    | 0.10927    | 0.10927    |   0.0 |  0.08
Output  | 0.00023662 | 0.00023662 | 0.00023662 |   0.0 |  0.00
Modify  | 0.45263    | 0.45263    | 0.45263    |   0.0 |  0.34
Other   |            | 0.06673    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.151949002538, Press = -5.32733096136798
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13475.115     -13475.115     -13547.333     -13547.333      279.48938      279.48938      31320.031      31320.031     -1426.5316     -1426.5316    
     16000  -13479.874     -13479.874     -13548.262     -13548.262      264.66868      264.66868      31311.6        31311.6       -1108.8495     -1108.8495    
Loop time of 135.221 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.639 ns/day, 37.561 hours/ns, 7.395 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    | 134.59     | 134.59     | 134.59     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10956    | 0.10956    | 0.10956    |   0.0 |  0.08
Output  | 0.00017026 | 0.00017026 | 0.00017026 |   0.0 |  0.00
Modify  | 0.45379    | 0.45379    | 0.45379    |   0.0 |  0.34
Other   |            | 0.06657    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.091077571613, Press = -5.28126908369227
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13479.874     -13479.874     -13548.262     -13548.262      264.66868      264.66868      31311.6        31311.6       -1108.8495     -1108.8495    
     17000  -13477.247     -13477.247     -13547.349     -13547.349      271.30184      271.30184      31319.581      31319.581     -1507.3597     -1507.3597    
Loop time of 128.933 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.815 hours/ns, 7.756 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.34     | 128.34     | 128.34     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10643    | 0.10643    | 0.10643    |   0.0 |  0.08
Output  | 0.00016644 | 0.00016644 | 0.00016644 |   0.0 |  0.00
Modify  | 0.42471    | 0.42471    | 0.42471    |   0.0 |  0.33
Other   |            | 0.06337    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.110639331565, Press = -5.81159693278676
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13477.247     -13477.247     -13547.349     -13547.349      271.30184      271.30184      31319.581      31319.581     -1507.3597     -1507.3597    
     18000  -13477.279     -13477.279     -13546.952     -13546.952      269.64155      269.64155      31323.203      31323.203     -1598.823      -1598.823     
Loop time of 126.776 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.2      | 126.2      | 126.2      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10292    | 0.10292    | 0.10292    |   0.0 |  0.08
Output  | 0.0002523  | 0.0002523  | 0.0002523  |   0.0 |  0.00
Modify  | 0.41328    | 0.41328    | 0.41328    |   0.0 |  0.33
Other   |            | 0.06286    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.993604162656, Press = -7.51034737820157
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13477.279     -13477.279     -13546.952     -13546.952      269.64155      269.64155      31323.203      31323.203     -1598.823      -1598.823     
     19000  -13477.118     -13477.118     -13547.372     -13547.372      271.89045      271.89045      31308.669      31308.669     -607.72106     -607.72106    
Loop time of 134.006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.224 hours/ns, 7.462 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    | 133.38     | 133.38     | 133.38     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10879    | 0.10879    | 0.10879    |   0.0 |  0.08
Output  | 0.00017314 | 0.00017314 | 0.00017314 |   0.0 |  0.00
Modify  | 0.45116    | 0.45116    | 0.45116    |   0.0 |  0.34
Other   |            | 0.06639    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.051932949251, Press = -8.12045405097941
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13477.118     -13477.118     -13547.372     -13547.372      271.89045      271.89045      31308.669      31308.669     -607.72106     -607.72106    
     20000  -13477.658     -13477.658     -13549.013     -13549.013      276.14912      276.14912      31296.744      31296.744      195.56554      195.56554    
Loop time of 119.752 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.21     | 119.21     | 119.21     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097429   | 0.097429   | 0.097429   |   0.0 |  0.08
Output  | 0.0001683  | 0.0001683  | 0.0001683  |   0.0 |  0.00
Modify  | 0.38227    | 0.38227    | 0.38227    |   0.0 |  0.32
Other   |            | 0.06006    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.041411357491, Press = -4.10868196193605
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13477.658     -13477.658     -13549.013     -13549.013      276.14912      276.14912      31296.744      31296.744      195.56554      195.56554    
     21000  -13477.063     -13477.063     -13548.027     -13548.027      274.63722      274.63722      31289.346      31289.346      1163.6256      1163.6256    
Loop time of 118.897 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.36     | 118.36     | 118.36     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097744   | 0.097744   | 0.097744   |   0.0 |  0.08
Output  | 0.00016913 | 0.00016913 | 0.00016913 |   0.0 |  0.00
Modify  | 0.37738    | 0.37738    | 0.37738    |   0.0 |  0.32
Other   |            | 0.06034    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.131202142703, Press = -2.23060247364869
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13477.063     -13477.063     -13548.027     -13548.027      274.63722      274.63722      31289.346      31289.346      1163.6256      1163.6256    
     22000  -13480.909     -13480.909     -13549.093     -13549.093      263.87802      263.87802      31271.946      31271.946      2267.0102      2267.0102    
Loop time of 124.001 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.445 hours/ns, 8.064 timesteps/s
100.0% 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.43     | 123.43     | 123.43     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10045    | 0.10045    | 0.10045    |   0.0 |  0.08
Output  | 0.0001665  | 0.0001665  | 0.0001665  |   0.0 |  0.00
Modify  | 0.40383    | 0.40383    | 0.40383    |   0.0 |  0.33
Other   |            | 0.06266    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.143493624699, Press = -1.60977721291822
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13480.909     -13480.909     -13549.093     -13549.093      263.87802      263.87802      31271.946      31271.946      2267.0102      2267.0102    
     23000  -13477.267     -13477.267     -13549.399     -13549.399      279.15767      279.15767      31266.657      31266.657      2720.4751      2720.4751    
Loop time of 114.289 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.747 hours/ns, 8.750 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.78     | 113.78     | 113.78     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092514   | 0.092514   | 0.092514   |   0.0 |  0.08
Output  | 0.00020406 | 0.00020406 | 0.00020406 |   0.0 |  0.00
Modify  | 0.35879    | 0.35879    | 0.35879    |   0.0 |  0.31
Other   |            | 0.05883    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.200643395041, Press = 0.151623908482774
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13477.267     -13477.267     -13549.399     -13549.399      279.15767      279.15767      31266.657      31266.657      2720.4751      2720.4751    
     24000  -13478.248     -13478.248     -13548.925     -13548.925      273.52717      273.52717      31274.643      31274.643      2146.4412      2146.4412    
Loop time of 114.304 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.751 hours/ns, 8.749 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.8      | 113.8      | 113.8      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093116   | 0.093116   | 0.093116   |   0.0 |  0.08
Output  | 0.00016741 | 0.00016741 | 0.00016741 |   0.0 |  0.00
Modify  | 0.35622    | 0.35622    | 0.35622    |   0.0 |  0.31
Other   |            | 0.05896    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.292888593957, Press = 1.55483565092887
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13478.248     -13478.248     -13548.925     -13548.925      273.52717      273.52717      31274.643      31274.643      2146.4412      2146.4412    
     25000  -13474.105     -13474.105     -13547.383     -13547.383      283.59046      283.59046      31307.024      31307.024     -270.5986      -270.5986     
Loop time of 128.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.786 hours/ns, 7.762 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.24     | 128.24     | 128.24     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10347    | 0.10347    | 0.10347    |   0.0 |  0.08
Output  | 0.00027572 | 0.00027572 | 0.00027572 |   0.0 |  0.00
Modify  | 0.4226     | 0.4226     | 0.4226     |   0.0 |  0.33
Other   |            | 0.06391    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.436331695566, Press = -0.217585312472352
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13474.105     -13474.105     -13547.383     -13547.383      283.59046      283.59046      31307.024      31307.024     -270.5986      -270.5986     
     26000  -13476.321     -13476.321     -13546.493     -13546.493      271.57095      271.57095      31310.177      31310.177     -677.30675     -677.30675    
Loop time of 129.186 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.669 ns/day, 35.885 hours/ns, 7.741 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.59     | 128.59     | 128.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10521    | 0.10521    | 0.10521    |   0.0 |  0.08
Output  | 0.00016629 | 0.00016629 | 0.00016629 |   0.0 |  0.00
Modify  | 0.42487    | 0.42487    | 0.42487    |   0.0 |  0.33
Other   |            | 0.0633     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.466179669238, Press = -1.22217579406225
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13476.321     -13476.321     -13546.493     -13546.493      271.57095      271.57095      31310.177      31310.177     -677.30675     -677.30675    
     27000  -13477.283     -13477.283     -13548.227     -13548.227      274.55965      274.55965      31307.013      31307.013     -591.34945     -591.34945    
Loop time of 120.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.577 hours/ns, 8.273 timesteps/s
100.0% 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.33     | 120.33     | 120.33     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097748   | 0.097748   | 0.097748   |   0.0 |  0.08
Output  | 0.00016972 | 0.00016972 | 0.00016972 |   0.0 |  0.00
Modify  | 0.386      | 0.386      | 0.386      |   0.0 |  0.32
Other   |            | 0.0616     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.568990789736, Press = -1.85599395030858
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13477.283     -13477.283     -13548.227     -13548.227      274.55965      274.55965      31307.013      31307.013     -591.34945     -591.34945    
     28000  -13474.486     -13474.486     -13546.509     -13546.509      278.73569      278.73569      31306.262      31306.262     -204.7251      -204.7251     
Loop time of 134.961 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.640 ns/day, 37.489 hours/ns, 7.410 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.33     | 134.33     | 134.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1093     | 0.1093     | 0.1093     |   0.0 |  0.08
Output  | 0.00024462 | 0.00024462 | 0.00024462 |   0.0 |  0.00
Modify  | 0.45115    | 0.45115    | 0.45115    |   0.0 |  0.33
Other   |            | 0.06671    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.584728098325, Press = -1.79310017985656
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13474.486     -13474.486     -13546.509     -13546.509      278.73569      278.73569      31306.262      31306.262     -204.7251      -204.7251     
     29000  -13478.597     -13478.597     -13548.362     -13548.362      269.99894      269.99894      31297.019      31297.019      175.39708      175.39708    
Loop time of 134.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.245 hours/ns, 7.458 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.46     | 133.46     | 133.46     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11166    | 0.11166    | 0.11166    |   0.0 |  0.08
Output  | 0.00017386 | 0.00017386 | 0.00017386 |   0.0 |  0.00
Modify  | 0.44728    | 0.44728    | 0.44728    |   0.0 |  0.33
Other   |            | 0.06434    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.649661280162, Press = -1.74686399528315
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13478.597     -13478.597     -13548.362     -13548.362      269.99894      269.99894      31297.019      31297.019      175.39708      175.39708    
     30000  -13476.016     -13476.016     -13545.829     -13545.829      270.18253      270.18253      31298.293      31298.293      503.20366      503.20366    
Loop time of 125.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.690 ns/day, 34.757 hours/ns, 7.992 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.55     | 124.55     | 124.55     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10334    | 0.10334    | 0.10334    |   0.0 |  0.08
Output  | 0.00017091 | 0.00017091 | 0.00017091 |   0.0 |  0.00
Modify  | 0.4097     | 0.4097     | 0.4097     |   0.0 |  0.33
Other   |            | 0.06216    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.771969382034, Press = -1.55429626060031
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13476.016     -13476.016     -13545.829     -13545.829      270.18253      270.18253      31298.293      31298.293      503.20366      503.20366    
     31000  -13476.204     -13476.204     -13546.591     -13546.591      272.40667      272.40667      31304.402      31304.402     -153.59283     -153.59283    
Loop time of 132.549 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.819 hours/ns, 7.544 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.93     | 131.93     | 131.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10674    | 0.10674    | 0.10674    |   0.0 |  0.08
Output  | 0.0001685  | 0.0001685  | 0.0001685  |   0.0 |  0.00
Modify  | 0.44241    | 0.44241    | 0.44241    |   0.0 |  0.33
Other   |            | 0.06585    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.785845392772, Press = -1.16076037070551
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13476.204     -13476.204     -13546.591     -13546.591      272.40667      272.40667      31304.402      31304.402     -153.59283     -153.59283    
     32000  -13478.856     -13478.856     -13548.394     -13548.394      269.12015      269.12015      31311.76       31311.76      -1044.9751     -1044.9751    
Loop time of 134.313 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.309 hours/ns, 7.445 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.69     | 133.69     | 133.69     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10915    | 0.10915    | 0.10915    |   0.0 |  0.08
Output  | 0.0001676  | 0.0001676  | 0.0001676  |   0.0 |  0.00
Modify  | 0.45219    | 0.45219    | 0.45219    |   0.0 |  0.34
Other   |            | 0.06612    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.847381479025, Press = -1.03921097194676
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13478.856     -13478.856     -13548.394     -13548.394      269.12015      269.12015      31311.76       31311.76      -1044.9751     -1044.9751    
     33000  -13475.558     -13475.558     -13544.88      -13544.88       268.28079      268.28079      31323.631      31323.631     -1670.1237     -1670.1237    
Loop time of 131.083 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.412 hours/ns, 7.629 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    | 130.48     | 130.48     | 130.48     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10573    | 0.10573    | 0.10573    |   0.0 |  0.08
Output  | 0.00020114 | 0.00020114 | 0.00020114 |   0.0 |  0.00
Modify  | 0.43512    | 0.43512    | 0.43512    |   0.0 |  0.33
Other   |            | 0.06474    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.806672678123, Press = -0.976661183988871
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13475.558     -13475.558     -13544.88      -13544.88       268.28079      268.28079      31323.631      31323.631     -1670.1237     -1670.1237    
     34000  -13479.111     -13479.111     -13547.017     -13547.017      262.8014       262.8014       31333.587      31333.587     -2859.2129     -2859.2129    
Loop time of 134.062 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.239 hours/ns, 7.459 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.44     | 133.44     | 133.44     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10779    | 0.10779    | 0.10779    |   0.0 |  0.08
Output  | 0.00016976 | 0.00016976 | 0.00016976 |   0.0 |  0.00
Modify  | 0.44663    | 0.44663    | 0.44663    |   0.0 |  0.33
Other   |            | 0.06656    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.819367072006, Press = -1.38844435330754
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13479.111     -13479.111     -13547.017     -13547.017      262.8014       262.8014       31333.587      31333.587     -2859.2129     -2859.2129    
     35000  -13479.98      -13479.98      -13547.116     -13547.116      259.82553      259.82553      31332.863      31332.863     -2680.2062     -2680.2062    
Loop time of 130.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.325 hours/ns, 7.647 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.17     | 130.17     | 130.17     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10659    | 0.10659    | 0.10659    |   0.0 |  0.08
Output  | 0.00016795 | 0.00016795 | 0.00016795 |   0.0 |  0.00
Modify  | 0.43363    | 0.43363    | 0.43363    |   0.0 |  0.33
Other   |            | 0.06501    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.819577554659, Press = -2.18291379134759
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13479.98      -13479.98      -13547.116     -13547.116      259.82553      259.82553      31332.863      31332.863     -2680.2062     -2680.2062    
     36000  -13475.518     -13475.518     -13548.188     -13548.188      281.24189      281.24189      31327.36       31327.36      -2138.0847     -2138.0847    
Loop time of 115.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.745 ns/day, 32.196 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    | 115.39     | 115.39     | 115.39     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099458   | 0.099458   | 0.099458   |   0.0 |  0.09
Output  | 0.00017452 | 0.00017452 | 0.00017452 |   0.0 |  0.00
Modify  | 0.36354    | 0.36354    | 0.36354    |   0.0 |  0.31
Other   |            | 0.05668    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.805763407219, Press = -2.87711605303943
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13475.518     -13475.518     -13548.188     -13548.188      281.24189      281.24189      31327.36       31327.36      -2138.0847     -2138.0847    
     37000  -13477.3       -13477.3       -13548.835     -13548.835      276.84941      276.84941      31307.873      31307.873     -600.67066     -600.67066    
Loop time of 121.085 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.635 hours/ns, 8.259 timesteps/s
100.0% 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.54     | 120.54     | 120.54     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10125    | 0.10125    | 0.10125    |   0.0 |  0.08
Output  | 0.00016848 | 0.00016848 | 0.00016848 |   0.0 |  0.00
Modify  | 0.38672    | 0.38672    | 0.38672    |   0.0 |  0.32
Other   |            | 0.05999    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.802065980113, Press = -3.50334694327526
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13477.3       -13477.3       -13548.835     -13548.835      276.84941      276.84941      31307.873      31307.873     -600.67066     -600.67066    
     38000  -13477.13      -13477.13      -13546.547     -13546.547      268.65285      268.65285      31290.222      31290.222      1170.4638      1170.4638    
Loop time of 122.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.704 ns/day, 34.092 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    | 122.17     | 122.17     | 122.17     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10298    | 0.10298    | 0.10298    |   0.0 |  0.08
Output  | 0.00043101 | 0.00043101 | 0.00043101 |   0.0 |  0.00
Modify  | 0.399      | 0.399      | 0.399      |   0.0 |  0.33
Other   |            | 0.06115    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.892717122916, Press = -2.28816654607478
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13477.13      -13477.13      -13546.547     -13546.547      268.65285      268.65285      31290.222      31290.222      1170.4638      1170.4638    
     39000  -13477.373     -13477.373     -13547.819     -13547.819      272.63323      272.63323      31291.134      31291.134      857.28338      857.28338    
Loop time of 124.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.538 hours/ns, 8.043 timesteps/s
100.0% 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.76     | 123.76     | 123.76     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10297    | 0.10297    | 0.10297    |   0.0 |  0.08
Output  | 0.00021814 | 0.00021814 | 0.00021814 |   0.0 |  0.00
Modify  | 0.40673    | 0.40673    | 0.40673    |   0.0 |  0.33
Other   |            | 0.06254    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.869797965843, Press = -1.56343285022924
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13477.373     -13477.373     -13547.819     -13547.819      272.63323      272.63323      31291.134      31291.134      857.28338      857.28338    
     40000  -13478.594     -13478.594     -13548.772     -13548.772      271.59466      271.59466      31281.319      31281.319      1506.2963      1506.2963    
Loop time of 133.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.127 hours/ns, 7.482 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.03     | 133.03     | 133.03     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10867    | 0.10867    | 0.10867    |   0.0 |  0.08
Output  | 0.00019838 | 0.00019838 | 0.00019838 |   0.0 |  0.00
Modify  | 0.45035    | 0.45035    | 0.45035    |   0.0 |  0.34
Other   |            | 0.06606    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.869697604992, Press = -1.06150860984212
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13478.594     -13478.594     -13548.772     -13548.772      271.59466      271.59466      31281.319      31281.319      1506.2963      1506.2963    
     41000  -13479.386     -13479.386     -13547.265     -13547.265      262.69946      262.69946      31269.156      31269.156      2603.2263      2603.2263    
Loop time of 133.695 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.137 hours/ns, 7.480 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.07     | 133.07     | 133.07     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10881    | 0.10881    | 0.10881    |   0.0 |  0.08
Output  | 0.00023188 | 0.00023188 | 0.00023188 |   0.0 |  0.00
Modify  | 0.44771    | 0.44771    | 0.44771    |   0.0 |  0.33
Other   |            | 0.06622    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.878925576284, Press = -0.10454733512822
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13479.386     -13479.386     -13547.265     -13547.265      262.69946      262.69946      31269.156      31269.156      2603.2263      2603.2263    
     42000  -13477.177     -13477.177     -13547.622     -13547.622      272.6297       272.6297       31270.713      31270.713      2429.8792      2429.8792    
Loop time of 122.732 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.704 ns/day, 34.092 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    | 122.17     | 122.17     | 122.17     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10209    | 0.10209    | 0.10209    |   0.0 |  0.08
Output  | 0.00020884 | 0.00020884 | 0.00020884 |   0.0 |  0.00
Modify  | 0.39739    | 0.39739    | 0.39739    |   0.0 |  0.32
Other   |            | 0.06041    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.84836805793, Press = 1.62299539016806
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13477.177     -13477.177     -13547.622     -13547.622      272.6297       272.6297       31270.713      31270.713      2429.8792      2429.8792    
     43000  -13477.183     -13477.183     -13548.478     -13548.478      275.91755      275.91755      31298.377      31298.377      168.94424      168.94424    
Loop time of 135.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.639 ns/day, 37.536 hours/ns, 7.400 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    | 134.5      | 134.5      | 134.5      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11366    | 0.11366    | 0.11366    |   0.0 |  0.08
Output  | 0.00024102 | 0.00024102 | 0.00024102 |   0.0 |  0.00
Modify  | 0.45433    | 0.45433    | 0.45433    |   0.0 |  0.34
Other   |            | 0.0654     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.849981954238, Press = 0.33009544313341
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13477.183     -13477.183     -13548.478     -13548.478      275.91755      275.91755      31298.377      31298.377      168.94424      168.94424    
     44000  -13474.207     -13474.207     -13545.87      -13545.87       277.34538      277.34538      31316.64       31316.64      -903.9209      -903.9209     
Loop time of 134.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.314 hours/ns, 7.444 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.7      | 133.7      | 133.7      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11307    | 0.11307    | 0.11307    |   0.0 |  0.08
Output  | 0.00023043 | 0.00023043 | 0.00023043 |   0.0 |  0.00
Modify  | 0.45437    | 0.45437    | 0.45437    |   0.0 |  0.34
Other   |            | 0.06483    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.870425177887, Press = -0.0534142318961255
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13474.207     -13474.207     -13545.87      -13545.87       277.34538      277.34538      31316.64       31316.64      -903.9209      -903.9209     
     45000  -13476.137     -13476.137     -13546.654     -13546.654      272.90906      272.90906      31326.194      31326.194     -1918.4538     -1918.4538    
Loop time of 123.785 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.698 ns/day, 34.385 hours/ns, 8.079 timesteps/s
100.0% 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.22     | 123.22     | 123.22     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10055    | 0.10055    | 0.10055    |   0.0 |  0.08
Output  | 0.0001709  | 0.0001709  | 0.0001709  |   0.0 |  0.00
Modify  | 0.40237    | 0.40237    | 0.40237    |   0.0 |  0.33
Other   |            | 0.0626     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.856371924881, Press = -0.504895180594692
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13476.137     -13476.137     -13546.654     -13546.654      272.90906      272.90906      31326.194      31326.194     -1918.4538     -1918.4538    
     46000  -13480.458     -13480.458     -13550.866     -13550.866      272.48822      272.48822      31325.908      31325.908     -2545.381      -2545.381     
Loop time of 134.138 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.261 hours/ns, 7.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    | 133.51     | 133.51     | 133.51     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11224    | 0.11224    | 0.11224    |   0.0 |  0.08
Output  | 0.00021387 | 0.00021387 | 0.00021387 |   0.0 |  0.00
Modify  | 0.44985    | 0.44985    | 0.44985    |   0.0 |  0.34
Other   |            | 0.06516    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.822779392938, Press = -0.895365504949704
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13480.458     -13480.458     -13550.866     -13550.866      272.48822      272.48822      31325.908      31325.908     -2545.381      -2545.381     
     47000  -13476.491     -13476.491     -13547.634     -13547.634      275.3293       275.3293       31356.074      31356.074     -4431.4092     -4431.4092    
Loop time of 134.314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.309 hours/ns, 7.445 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.69     | 133.69     | 133.69     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11292    | 0.11292    | 0.11292    |   0.0 |  0.08
Output  | 0.00016951 | 0.00016951 | 0.00016951 |   0.0 |  0.00
Modify  | 0.44901    | 0.44901    | 0.44901    |   0.0 |  0.33
Other   |            | 0.0647     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.823869848631, Press = -1.68364099062311
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13476.491     -13476.491     -13547.634     -13547.634      275.3293       275.3293       31356.074      31356.074     -4431.4092     -4431.4092    
     48000  -13479.987     -13479.987     -13548.517     -13548.517      265.2182       265.2182       31336.856      31336.856     -2961.5206     -2961.5206    
Loop time of 121.222 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.673 hours/ns, 8.249 timesteps/s
100.0% 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.67     | 120.67     | 120.67     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099536   | 0.099536   | 0.099536   |   0.0 |  0.08
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.39076    | 0.39076    | 0.39076    |   0.0 |  0.32
Other   |            | 0.06125    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.78099338059, Press = -2.01198653252671
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13479.987     -13479.987     -13548.517     -13548.517      265.2182       265.2182       31336.856      31336.856     -2961.5206     -2961.5206    
     49000  -13475.473     -13475.473     -13544.959     -13544.959      268.91785      268.91785      31313.696      31313.696     -441.45457     -441.45457    
Loop time of 117.522 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.99     | 116.99     | 116.99     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096618   | 0.096618   | 0.096618   |   0.0 |  0.08
Output  | 0.00024747 | 0.00024747 | 0.00024747 |   0.0 |  0.00
Modify  | 0.37193    | 0.37193    | 0.37193    |   0.0 |  0.32
Other   |            | 0.05984    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.769658978587, Press = -1.30248924953768
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13475.473     -13475.473     -13544.959     -13544.959      268.91785      268.91785      31313.696      31313.696     -441.45457     -441.45457    
     50000  -13477.115     -13477.115     -13546.792     -13546.792      269.65763      269.65763      31309.229      31309.229     -384.13122     -384.13122    
Loop time of 130.519 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.662 ns/day, 36.255 hours/ns, 7.662 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.91     | 129.91     | 129.91     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10585    | 0.10585    | 0.10585    |   0.0 |  0.08
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.43243    | 0.43243    | 0.43243    |   0.0 |  0.33
Other   |            | 0.06564    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.778689290022, Press = -1.40041667223858
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13477.115     -13477.115     -13546.792     -13546.792      269.65763      269.65763      31309.229      31309.229     -384.13122     -384.13122    
     51000  -13474.076     -13474.076     -13545.88      -13545.88       277.88783      277.88783      31306.353      31306.353      127.59282      127.59282    
Loop time of 134.118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.255 hours/ns, 7.456 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    | 133.5      | 133.5      | 133.5      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10875    | 0.10875    | 0.10875    |   0.0 |  0.08
Output  | 0.00016805 | 0.00016805 | 0.00016805 |   0.0 |  0.00
Modify  | 0.44796    | 0.44796    | 0.44796    |   0.0 |  0.33
Other   |            | 0.0657     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.789933749992, Press = -1.70543588511748
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13474.076     -13474.076     -13545.88      -13545.88       277.88783      277.88783      31306.353      31306.353      127.59282      127.59282    
     52000  -13478.029     -13478.029     -13549.165     -13549.165      275.30235      275.30235      31289.088      31289.088      997.01578      997.01578    
Loop time of 128.865 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.796 hours/ns, 7.760 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.27     | 128.27     | 128.27     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10426    | 0.10426    | 0.10426    |   0.0 |  0.08
Output  | 0.00016865 | 0.00016865 | 0.00016865 |   0.0 |  0.00
Modify  | 0.42598    | 0.42598    | 0.42598    |   0.0 |  0.33
Other   |            | 0.06378    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.837988228879, Press = -1.84796123042415
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13478.029     -13478.029     -13549.165     -13549.165      275.30235      275.30235      31289.088      31289.088      997.01578      997.01578    
     53000  -13476.965     -13476.965     -13548.333     -13548.333      276.19869      276.19869      31265.216      31265.216      2957.9303      2957.9303    
Loop time of 117.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.733 ns/day, 32.756 hours/ns, 8.480 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    | 117.39     | 117.39     | 117.39     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096135   | 0.096135   | 0.096135   |   0.0 |  0.08
Output  | 0.00017034 | 0.00017034 | 0.00017034 |   0.0 |  0.00
Modify  | 0.37469    | 0.37469    | 0.37469    |   0.0 |  0.32
Other   |            | 0.06034    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.859528655943, Press = -1.93454818241427
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13476.965     -13476.965     -13548.333     -13548.333      276.19869      276.19869      31265.216      31265.216      2957.9303      2957.9303    
     54000  -13477.379     -13477.379     -13548.797     -13548.797      276.39524      276.39524      31270.076      31270.076      2498.9566      2498.9566    
Loop time of 114.681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.753 ns/day, 31.856 hours/ns, 8.720 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.17     | 114.17     | 114.17     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09377    | 0.09377    | 0.09377    |   0.0 |  0.08
Output  | 0.00016901 | 0.00016901 | 0.00016901 |   0.0 |  0.00
Modify  | 0.35922    | 0.35922    | 0.35922    |   0.0 |  0.31
Other   |            | 0.0589     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.815036599009, Press = -0.97274517112453
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13477.379     -13477.379     -13548.797     -13548.797      276.39524      276.39524      31270.076      31270.076      2498.9566      2498.9566    
     55000  -13478.518     -13478.518     -13548.459     -13548.459      270.67968      270.67968      31275.198      31275.198      2051.8779      2051.8779    
Loop time of 115.97 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.745 ns/day, 32.214 hours/ns, 8.623 timesteps/s
100.0% 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.45     | 115.45     | 115.45     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094557   | 0.094557   | 0.094557   |   0.0 |  0.08
Output  | 0.00017058 | 0.00017058 | 0.00017058 |   0.0 |  0.00
Modify  | 0.36235    | 0.36235    | 0.36235    |   0.0 |  0.31
Other   |            | 0.05931    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.811506170856, Press = -0.520861410613635
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13478.518     -13478.518     -13548.459     -13548.459      270.67968      270.67968      31275.198      31275.198      2051.8779      2051.8779    
     56000  -13475.892     -13475.892     -13548.243     -13548.243      280.00708      280.00708      31282.954      31282.954      1515.9236      1515.9236    
Loop time of 127.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.677 ns/day, 35.444 hours/ns, 7.837 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.01     | 127.01     | 127.01     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10383    | 0.10383    | 0.10383    |   0.0 |  0.08
Output  | 0.00023093 | 0.00023093 | 0.00023093 |   0.0 |  0.00
Modify  | 0.41759    | 0.41759    | 0.41759    |   0.0 |  0.33
Other   |            | 0.0631     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.79669621743, Press = -0.249365165395553
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13475.892     -13475.892     -13548.243     -13548.243      280.00708      280.00708      31282.954      31282.954      1515.9236      1515.9236    
     57000  -13479.797     -13479.797     -13547.598     -13547.598      262.39747      262.39747      31274.916      31274.916      2094.4775      2094.4775    
Loop time of 117.078 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.738 ns/day, 32.522 hours/ns, 8.541 timesteps/s
100.0% 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.55     | 116.55     | 116.55     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097224   | 0.097224   | 0.097224   |   0.0 |  0.08
Output  | 0.00016694 | 0.00016694 | 0.00016694 |   0.0 |  0.00
Modify  | 0.37152    | 0.37152    | 0.37152    |   0.0 |  0.32
Other   |            | 0.05956    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.759293387204, Press = -0.0961454740760972
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13479.797     -13479.797     -13547.598     -13547.598      262.39747      262.39747      31274.916      31274.916      2094.4775      2094.4775    
     58000  -13477.38      -13477.38      -13547.366     -13547.366      270.85199      270.85199      31282.535      31282.535      1569.5948      1569.5948    
Loop time of 123.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.312 hours/ns, 8.096 timesteps/s
100.0% 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.96     | 122.96     | 122.96     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10151    | 0.10151    | 0.10151    |   0.0 |  0.08
Output  | 0.00021174 | 0.00021174 | 0.00021174 |   0.0 |  0.00
Modify  | 0.39977    | 0.39977    | 0.39977    |   0.0 |  0.32
Other   |            | 0.06254    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.746190181186, Press = 0.41650914622696
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13477.38      -13477.38      -13547.366     -13547.366      270.85199      270.85199      31282.535      31282.535      1569.5948      1569.5948    
     59000  -13474.734     -13474.734     -13547.154     -13547.154      280.27312      280.27312      31299.371      31299.371      329.66231      329.66231    
Loop time of 135.557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.655 hours/ns, 7.377 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    | 134.92     | 134.92     | 134.92     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11031    | 0.11031    | 0.11031    |   0.0 |  0.08
Output  | 0.0001812  | 0.0001812  | 0.0001812  |   0.0 |  0.00
Modify  | 0.45718    | 0.45718    | 0.45718    |   0.0 |  0.34
Other   |            | 0.06679    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.72742377037, Press = 1.0839334655638
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13474.734     -13474.734     -13547.154     -13547.154      280.27312      280.27312      31299.371      31299.371      329.66231      329.66231    
     60000  -13475.403     -13475.403     -13546.432     -13546.432      274.88952      274.88952      31313.187      31313.187     -832.76692     -832.76692    
Loop time of 123.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.180 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    | 122.49     | 122.49     | 122.49     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10319    | 0.10319    | 0.10319    |   0.0 |  0.08
Output  | 0.0002069  | 0.0002069  | 0.0002069  |   0.0 |  0.00
Modify  | 0.39852    | 0.39852    | 0.39852    |   0.0 |  0.32
Other   |            | 0.06108    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.740405536073, Press = 0.292460896683026
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13475.403     -13475.403     -13546.432     -13546.432      274.88952      274.88952      31313.187      31313.187     -832.76692     -832.76692    
     61000  -13474.22      -13474.22      -13546.414     -13546.414      279.39622      279.39622      31320.231      31320.231     -1366.8116     -1366.8116    
Loop time of 115.465 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.748 ns/day, 32.074 hours/ns, 8.661 timesteps/s
100.0% 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.94     | 114.94     | 114.94     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096558   | 0.096558   | 0.096558   |   0.0 |  0.08
Output  | 0.00017034 | 0.00017034 | 0.00017034 |   0.0 |  0.00
Modify  | 0.36488    | 0.36488    | 0.36488    |   0.0 |  0.32
Other   |            | 0.0592     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.746499852715, Press = -0.00384329500482942
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13474.22      -13474.22      -13546.414     -13546.414      279.39622      279.39622      31320.231      31320.231     -1366.8116     -1366.8116    
     62000  -13477.423     -13477.423     -13547.901     -13547.901      272.75461      272.75461      31321.105      31321.105     -1642.0227     -1642.0227    
Loop time of 115.356 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.749 ns/day, 32.043 hours/ns, 8.669 timesteps/s
100.0% 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.84     | 114.84     | 114.84     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095422   | 0.095422   | 0.095422   |   0.0 |  0.08
Output  | 0.00028498 | 0.00028498 | 0.00028498 |   0.0 |  0.00
Modify  | 0.3645     | 0.3645     | 0.3645     |   0.0 |  0.32
Other   |            | 0.05899    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.804950337518, Press = -0.312815873583081
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13477.423     -13477.423     -13547.901     -13547.901      272.75461      272.75461      31321.105      31321.105     -1642.0227     -1642.0227    
     63000  -13476.404     -13476.404     -13548.205     -13548.205      277.87716      277.87716      31328.981      31328.981     -2172.8355     -2172.8355    
Loop time of 115.794 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.746 ns/day, 32.165 hours/ns, 8.636 timesteps/s
100.0% 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.27     | 115.27     | 115.27     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096446   | 0.096446   | 0.096446   |   0.0 |  0.08
Output  | 0.00016878 | 0.00016878 | 0.00016878 |   0.0 |  0.00
Modify  | 0.36462    | 0.36462    | 0.36462    |   0.0 |  0.31
Other   |            | 0.05888    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.798451742546, Press = -0.575092502817578
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13476.404     -13476.404     -13548.205     -13548.205      277.87716      277.87716      31328.981      31328.981     -2172.8355     -2172.8355    
     64000  -13481.735     -13481.735     -13550.94      -13550.94       267.8313       267.8313       31347.922      31347.922     -4374.3484     -4374.3484    
Loop time of 116.207 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.743 ns/day, 32.280 hours/ns, 8.605 timesteps/s
100.0% 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.68     | 115.68     | 115.68     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098522   | 0.098522   | 0.098522   |   0.0 |  0.08
Output  | 0.00017081 | 0.00017081 | 0.00017081 |   0.0 |  0.00
Modify  | 0.36637    | 0.36637    | 0.36637    |   0.0 |  0.32
Other   |            | 0.0576     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.789048132953, Press = -1.25205113338394
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13481.735     -13481.735     -13550.94      -13550.94       267.8313       267.8313       31347.922      31347.922     -4374.3484     -4374.3484    
     65000  -13476.62      -13476.62      -13545.9       -13545.9        268.12135      268.12135      31341.875      31341.875     -3041.9943     -3041.9943    
Loop time of 121.06 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.628 hours/ns, 8.260 timesteps/s
100.0% 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.51     | 120.51     | 120.51     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1006     | 0.1006     | 0.1006     |   0.0 |  0.08
Output  | 0.00022247 | 0.00022247 | 0.00022247 |   0.0 |  0.00
Modify  | 0.38697    | 0.38697    | 0.38697    |   0.0 |  0.32
Other   |            | 0.06056    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.750199399276, Press = -1.45391080258783
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13476.62      -13476.62      -13545.9       -13545.9        268.12135      268.12135      31341.875      31341.875     -3041.9943     -3041.9943    
     66000  -13478.431     -13478.431     -13547.759     -13547.759      268.30377      268.30377      31312.01       31312.01      -877.51021     -877.51021    
Loop time of 134.844 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.641 ns/day, 37.457 hours/ns, 7.416 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 134.22     | 134.22     | 134.22     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11072    | 0.11072    | 0.11072    |   0.0 |  0.08
Output  | 0.000211   | 0.000211   | 0.000211   |   0.0 |  0.00
Modify  | 0.45147    | 0.45147    | 0.45147    |   0.0 |  0.33
Other   |            | 0.06599    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.7399879266, Press = -1.00045865647269
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13478.431     -13478.431     -13547.759     -13547.759      268.30377      268.30377      31312.01       31312.01      -877.51021     -877.51021    
     67000  -13479.185     -13479.185     -13549.833     -13549.833      273.41389      273.41389      31295.799      31295.799      139.73744      139.73744    
Loop time of 133.48 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.078 hours/ns, 7.492 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.86     | 132.86     | 132.86     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10796    | 0.10796    | 0.10796    |   0.0 |  0.08
Output  | 0.00016807 | 0.00016807 | 0.00016807 |   0.0 |  0.00
Modify  | 0.44505    | 0.44505    | 0.44505    |   0.0 |  0.33
Other   |            | 0.0659     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.709324232376, Press = -0.986163195956013
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13479.185     -13479.185     -13549.833     -13549.833      273.41389      273.41389      31295.799      31295.799      139.73744      139.73744    
     68000  -13477.646     -13477.646     -13549.202     -13549.202      276.93059      276.93059      31288.583      31288.583      1006.8588      1006.8588    
Loop time of 128.925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.813 hours/ns, 7.756 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.33     | 128.33     | 128.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10579    | 0.10579    | 0.10579    |   0.0 |  0.08
Output  | 0.00022317 | 0.00022317 | 0.00022317 |   0.0 |  0.00
Modify  | 0.42786    | 0.42786    | 0.42786    |   0.0 |  0.33
Other   |            | 0.06437    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.727545196362, Press = -0.753131705281867
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13477.646     -13477.646     -13549.202     -13549.202      276.93059      276.93059      31288.583      31288.583      1006.8588      1006.8588    
     69000  -13479.351     -13479.351     -13549.077     -13549.077      269.8459       269.8459       31278.991      31278.991      1684.5037      1684.5037    
Loop time of 129.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 36.006 hours/ns, 7.715 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.02     | 129.02     | 129.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10565    | 0.10565    | 0.10565    |   0.0 |  0.08
Output  | 0.00047123 | 0.00047123 | 0.00047123 |   0.0 |  0.00
Modify  | 0.42695    | 0.42695    | 0.42695    |   0.0 |  0.33
Other   |            | 0.06461    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.722926092778, Press = -0.438769828758299
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13479.351     -13479.351     -13549.077     -13549.077      269.8459       269.8459       31278.991      31278.991      1684.5037      1684.5037    
     70000  -13475.47      -13475.47      -13546.936     -13546.936      276.58044      276.58044      31259.367      31259.367      3773.7174      3773.7174    
Loop time of 133.292 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.026 hours/ns, 7.502 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.67     | 132.67     | 132.67     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10968    | 0.10968    | 0.10968    |   0.0 |  0.08
Output  | 0.00016817 | 0.00016817 | 0.00016817 |   0.0 |  0.00
Modify  | 0.44597    | 0.44597    | 0.44597    |   0.0 |  0.33
Other   |            | 0.06633    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.704127106554, Press = 0.0195820530340083
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13475.47      -13475.47      -13546.936     -13546.936      276.58044      276.58044      31259.367      31259.367      3773.7174      3773.7174    
     71000  -13477.05      -13477.05      -13549.44      -13549.44       280.15534      280.15534      31258.541      31258.541      3467.1982      3467.1982    
Loop time of 128.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.672 ns/day, 35.695 hours/ns, 7.782 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.91     | 127.91     | 127.91     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10488    | 0.10488    | 0.10488    |   0.0 |  0.08
Output  | 0.00016959 | 0.00016959 | 0.00016959 |   0.0 |  0.00
Modify  | 0.42276    | 0.42276    | 0.42276    |   0.0 |  0.33
Other   |            | 0.06424    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.711715688752, Press = 0.601137619580544
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13477.05      -13477.05      -13549.44      -13549.44       280.15534      280.15534      31258.541      31258.541      3467.1982      3467.1982    
     72000  -13477.619     -13477.619     -13547.301     -13547.301      269.67654      269.67654      31285.422      31285.422      1373.5963      1373.5963    
Loop time of 131.049 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.403 hours/ns, 7.631 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.45     | 130.45     | 130.45     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10574    | 0.10574    | 0.10574    |   0.0 |  0.08
Output  | 0.00017308 | 0.00017308 | 0.00017308 |   0.0 |  0.00
Modify  | 0.43281    | 0.43281    | 0.43281    |   0.0 |  0.33
Other   |            | 0.06565    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.762205778513, Press = 0.339320541668598
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13477.619     -13477.619     -13547.301     -13547.301      269.67654      269.67654      31285.422      31285.422      1373.5963      1373.5963    
     73000  -13474.381     -13474.381     -13547.271     -13547.271      282.09325      282.09325      31306.002      31306.002     -394.70378     -394.70378    
Loop time of 131.981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.661 hours/ns, 7.577 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.37     | 131.37     | 131.37     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10764    | 0.10764    | 0.10764    |   0.0 |  0.08
Output  | 0.00023078 | 0.00023078 | 0.00023078 |   0.0 |  0.00
Modify  | 0.43957    | 0.43957    | 0.43957    |   0.0 |  0.33
Other   |            | 0.06627    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.784285188572, Press = 0.335821426728046
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13474.381     -13474.381     -13547.271     -13547.271      282.09325      282.09325      31306.002      31306.002     -394.70378     -394.70378    
     74000  -13478.837     -13478.837     -13550.399     -13550.399      276.95395      276.95395      31309.145      31309.145     -1057.4235     -1057.4235    
Loop time of 133.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.193 hours/ns, 7.469 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.27     | 133.27     | 133.27     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10896    | 0.10896    | 0.10896    |   0.0 |  0.08
Output  | 0.00016909 | 0.00016909 | 0.00016909 |   0.0 |  0.00
Modify  | 0.44937    | 0.44937    | 0.44937    |   0.0 |  0.34
Other   |            | 0.06531    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.822225571751, Press = 0.230027644603124
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13478.837     -13478.837     -13550.399     -13550.399      276.95395      276.95395      31309.145      31309.145     -1057.4235     -1057.4235    
     75000  -13477.728     -13477.728     -13547.945     -13547.945      271.7459       271.7459       31325.135      31325.135     -1934.0512     -1934.0512    
Loop time of 132.498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.805 hours/ns, 7.547 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    | 131.88     | 131.88     | 131.88     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11022    | 0.11022    | 0.11022    |   0.0 |  0.08
Output  | 0.00017401 | 0.00017401 | 0.00017401 |   0.0 |  0.00
Modify  | 0.44218    | 0.44218    | 0.44218    |   0.0 |  0.33
Other   |            | 0.06405    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.844324084107, Press = 0.119747600248309
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -13477.728     -13477.728     -13547.945     -13547.945      271.7459       271.7459       31325.135      31325.135     -1934.0512     -1934.0512    
     76000  -13474.188     -13474.188     -13545.125     -13545.125      274.53327      274.53327      31366.082      31366.082     -5180.2005     -5180.2005    
Loop time of 133.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.087 hours/ns, 7.490 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    | 132.9      | 132.9      | 132.9      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10845    | 0.10845    | 0.10845    |   0.0 |  0.08
Output  | 0.00016932 | 0.00016932 | 0.00016932 |   0.0 |  0.00
Modify  | 0.44405    | 0.44405    | 0.44405    |   0.0 |  0.33
Other   |            | 0.06627    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.84763530142, Press = -0.0467107914274953
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -13474.188     -13474.188     -13545.125     -13545.125      274.53327      274.53327      31366.082      31366.082     -5180.2005     -5180.2005    
     77000  -13478.588     -13478.588     -13548.476     -13548.476      270.4731       270.4731       31327.732      31327.732     -2406.3723     -2406.3723    
Loop time of 134.469 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.84     | 133.84     | 133.84     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10911    | 0.10911    | 0.10911    |   0.0 |  0.08
Output  | 0.00016991 | 0.00016991 | 0.00016991 |   0.0 |  0.00
Modify  | 0.45018    | 0.45018    | 0.45018    |   0.0 |  0.33
Other   |            | 0.06784    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.8759157249, Press = -0.453356573998677
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -13478.588     -13478.588     -13548.476     -13548.476      270.4731       270.4731       31327.732      31327.732     -2406.3723     -2406.3723    
     78000  -13476.132     -13476.132     -13546.785     -13546.785      273.43406      273.43406      31314.88       31314.88      -910.77925     -910.77925    
Loop time of 134.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.642 ns/day, 37.357 hours/ns, 7.436 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.86     | 133.86     | 133.86     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1087     | 0.1087     | 0.1087     |   0.0 |  0.08
Output  | 0.00021313 | 0.00021313 | 0.00021313 |   0.0 |  0.00
Modify  | 0.44952    | 0.44952    | 0.44952    |   0.0 |  0.33
Other   |            | 0.06642    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.889590650936, Press = -0.559698212300051
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -13476.132     -13476.132     -13546.785     -13546.785      273.43406      273.43406      31314.88       31314.88      -910.77925     -910.77925    
     79000  -13481.521     -13481.521     -13550.368     -13550.368      266.44795      266.44795      31297.597      31297.597     -58.251546     -58.251546    
Loop time of 130.934 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.370 hours/ns, 7.637 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    | 130.33     | 130.33     | 130.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10716    | 0.10716    | 0.10716    |   0.0 |  0.08
Output  | 0.00020428 | 0.00020428 | 0.00020428 |   0.0 |  0.00
Modify  | 0.43316    | 0.43316    | 0.43316    |   0.0 |  0.33
Other   |            | 0.06455    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.881913013715, Press = -0.678968191345242
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -13481.521     -13481.521     -13550.368     -13550.368      266.44795      266.44795      31297.597      31297.597     -58.251546     -58.251546    
     80000  -13476.836     -13476.836     -13546.735     -13546.735      270.5151       270.5151       31288.443      31288.443      1010.0456      1010.0456    
Loop time of 128.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.746 hours/ns, 7.771 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.09     | 128.09     | 128.09     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10608    | 0.10608    | 0.10608    |   0.0 |  0.08
Output  | 0.00017139 | 0.00017139 | 0.00017139 |   0.0 |  0.00
Modify  | 0.42722    | 0.42722    | 0.42722    |   0.0 |  0.33
Other   |            | 0.0633     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.868415653238, Press = -0.697021261458732
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -13476.836     -13476.836     -13546.735     -13546.735      270.5151       270.5151       31288.443      31288.443      1010.0456      1010.0456    
     81000  -13477.495     -13477.495     -13548.678     -13548.678      275.48832      275.48832      31259.516      31259.516      3172.6217      3172.6217    
Loop time of 120.213 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.719 ns/day, 33.392 hours/ns, 8.319 timesteps/s
100.0% 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.67     | 119.67     | 119.67     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098942   | 0.098942   | 0.098942   |   0.0 |  0.08
Output  | 0.00021567 | 0.00021567 | 0.00021567 |   0.0 |  0.00
Modify  | 0.38444    | 0.38444    | 0.38444    |   0.0 |  0.32
Other   |            | 0.06019    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.839235751283, Press = -0.856139108617214
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -13477.495     -13477.495     -13548.678     -13548.678      275.48832      275.48832      31259.516      31259.516      3172.6217      3172.6217    
     82000  -13478.194     -13478.194     -13548.773     -13548.773      273.14499      273.14499      31262.461      31262.461      3014.2723      3014.2723    
Loop time of 134.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.252 hours/ns, 7.457 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.48     | 133.48     | 133.48     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10917    | 0.10917    | 0.10917    |   0.0 |  0.08
Output  | 0.00020279 | 0.00020279 | 0.00020279 |   0.0 |  0.00
Modify  | 0.44624    | 0.44624    | 0.44624    |   0.0 |  0.33
Other   |            | 0.06651    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.855646513384, Press = -0.442463709573984
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -13478.194     -13478.194     -13548.773     -13548.773      273.14499      273.14499      31262.461      31262.461      3014.2723      3014.2723    
     83000  -13474.152     -13474.152     -13546.88      -13546.88       281.46552      281.46552      31283.34       31283.34       1595.1794      1595.1794    
Loop time of 127.538 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.95     | 126.95     | 126.95     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1048     | 0.1048     | 0.1048     |   0.0 |  0.08
Output  | 0.00020976 | 0.00020976 | 0.00020976 |   0.0 |  0.00
Modify  | 0.41744    | 0.41744    | 0.41744    |   0.0 |  0.33
Other   |            | 0.06311    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.886496071719, Press = -0.0112581850531607
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -13474.152     -13474.152     -13546.88      -13546.88       281.46552      281.46552      31283.34       31283.34       1595.1794      1595.1794    
     84000  -13478.376     -13478.376     -13549.212     -13549.212      274.14051      274.14051      31281.982      31281.982      1275.0415      1275.0415    
Loop time of 125.164 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.59     | 124.59     | 124.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10278    | 0.10278    | 0.10278    |   0.0 |  0.08
Output  | 0.00020876 | 0.00020876 | 0.00020876 |   0.0 |  0.00
Modify  | 0.40795    | 0.40795    | 0.40795    |   0.0 |  0.33
Other   |            | 0.06266    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.909845148795, Press = 0.20841211452764
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -13478.376     -13478.376     -13549.212     -13549.212      274.14051      274.14051      31281.982      31281.982      1275.0415      1275.0415    
     85000  -13478.901     -13478.901     -13548.567     -13548.567      269.6157       269.6157       31277.331      31277.331      1816.2903      1816.2903    
Loop time of 127.677 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.09     | 127.09     | 127.09     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1049     | 0.1049     | 0.1049     |   0.0 |  0.08
Output  | 0.00017031 | 0.00017031 | 0.00017031 |   0.0 |  0.00
Modify  | 0.42026    | 0.42026    | 0.42026    |   0.0 |  0.33
Other   |            | 0.06381    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.928645977593, Press = 0.327853912645193
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -13478.901     -13478.901     -13548.567     -13548.567      269.6157       269.6157       31277.331      31277.331      1816.2903      1816.2903    
     86000  -13479.823     -13479.823     -13548.264     -13548.264      264.87459      264.87459      31270.985      31270.985      2375.1398      2375.1398    
Loop time of 133.64 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.122 hours/ns, 7.483 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.02     | 133.02     | 133.02     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10897    | 0.10897    | 0.10897    |   0.0 |  0.08
Output  | 0.00016974 | 0.00016974 | 0.00016974 |   0.0 |  0.00
Modify  | 0.4468     | 0.4468     | 0.4468     |   0.0 |  0.33
Other   |            | 0.06569    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.923912761441, Press = 0.834218936004642
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -13479.823     -13479.823     -13548.264     -13548.264      264.87459      264.87459      31270.985      31270.985      2375.1398      2375.1398    
     87000  -13475.133     -13475.133     -13547.182     -13547.182      278.83853      278.83853      31300.661      31300.661      292.20379      292.20379    
Loop time of 132.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.805 hours/ns, 7.547 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    | 131.88     | 131.88     | 131.88     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10942    | 0.10942    | 0.10942    |   0.0 |  0.08
Output  | 0.00016926 | 0.00016926 | 0.00016926 |   0.0 |  0.00
Modify  | 0.44092    | 0.44092    | 0.44092    |   0.0 |  0.33
Other   |            | 0.06497    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.912646751039, Press = 0.40994159920363
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -13475.133     -13475.133     -13547.182     -13547.182      278.83853      278.83853      31300.661      31300.661      292.20379      292.20379    
     88000  -13480.81      -13480.81      -13550.662     -13550.662      270.3361       270.3361       31307.452      31307.452     -1008.3154     -1008.3154    
Loop time of 133.796 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.166 hours/ns, 7.474 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.17     | 133.17     | 133.17     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10932    | 0.10932    | 0.10932    |   0.0 |  0.08
Output  | 0.00016888 | 0.00016888 | 0.00016888 |   0.0 |  0.00
Modify  | 0.4494     | 0.4494     | 0.4494     |   0.0 |  0.34
Other   |            | 0.06605    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.888027254616, Press = 0.0715308508644977
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -13480.81      -13480.81      -13550.662     -13550.662      270.3361       270.3361       31307.452      31307.452     -1008.3154     -1008.3154    
     89000  -13476.126     -13476.126     -13547.826     -13547.826      277.48395      277.48395      31323.77       31323.77      -1923.2191     -1923.2191    
Loop time of 132.382 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.773 hours/ns, 7.554 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    | 131.77     | 131.77     | 131.77     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10917    | 0.10917    | 0.10917    |   0.0 |  0.08
Output  | 0.00021314 | 0.00021314 | 0.00021314 |   0.0 |  0.00
Modify  | 0.44228    | 0.44228    | 0.44228    |   0.0 |  0.33
Other   |            | 0.06514    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.885649322857, Press = 0.0321299066617429
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -13476.126     -13476.126     -13547.826     -13547.826      277.48395      277.48395      31323.77       31323.77      -1923.2191     -1923.2191    
     90000  -13479.866     -13479.866     -13548.679     -13548.679      266.31013      266.31013      31334.177      31334.177     -2945.9904     -2945.9904    
Loop time of 134.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.640 ns/day, 37.471 hours/ns, 7.413 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    | 134.27     | 134.27     | 134.27     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11407    | 0.11407    | 0.11407    |   0.0 |  0.08
Output  | 0.00016913 | 0.00016913 | 0.00016913 |   0.0 |  0.00
Modify  | 0.45111    | 0.45111    | 0.45111    |   0.0 |  0.33
Other   |            | 0.06447    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.867533347193, Press = -0.124048833126582
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -13479.866     -13479.866     -13548.679     -13548.679      266.31013      266.31013      31334.177      31334.177     -2945.9904     -2945.9904    
     91000  -13476.562     -13476.562     -13547.264     -13547.264      273.62614      273.62614      31361.395      31361.395     -5043.7151     -5043.7151    
Loop time of 133.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.969 hours/ns, 7.514 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.47     | 132.47     | 132.47     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10864    | 0.10864    | 0.10864    |   0.0 |  0.08
Output  | 0.00020911 | 0.00020911 | 0.00020911 |   0.0 |  0.00
Modify  | 0.44482    | 0.44482    | 0.44482    |   0.0 |  0.33
Other   |            | 0.06492    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.845418452881, Press = -0.438820633387069
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -13476.562     -13476.562     -13547.264     -13547.264      273.62614      273.62614      31361.395      31361.395     -5043.7151     -5043.7151    
     92000  -13478.766     -13478.766     -13546.678     -13546.678      262.82647      262.82647      31326.516      31326.516     -2230.3501     -2230.3501    
Loop time of 134.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.228 hours/ns, 7.461 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.4      | 133.4      | 133.4      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10881    | 0.10881    | 0.10881    |   0.0 |  0.08
Output  | 0.00016867 | 0.00016867 | 0.00016867 |   0.0 |  0.00
Modify  | 0.44521    | 0.44521    | 0.44521    |   0.0 |  0.33
Other   |            | 0.06521    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.851570483011, Press = -0.456831333861438
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -13478.766     -13478.766     -13546.678     -13546.678      262.82647      262.82647      31326.516      31326.516     -2230.3501     -2230.3501    
     93000  -13476.289     -13476.289     -13547.235     -13547.235      274.56688      274.56688      31308.288      31308.288     -619.0789      -619.0789     
Loop time of 121.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.857 hours/ns, 8.204 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.33     | 121.33     | 121.33     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099862   | 0.099862   | 0.099862   |   0.0 |  0.08
Output  | 0.00017077 | 0.00017077 | 0.00017077 |   0.0 |  0.00
Modify  | 0.39061    | 0.39061    | 0.39061    |   0.0 |  0.32
Other   |            | 0.06049    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.880400140387, Press = -0.213835460950129
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -13476.289     -13476.289     -13547.235     -13547.235      274.56688      274.56688      31308.288      31308.288     -619.0789      -619.0789     
     94000  -13477.123     -13477.123     -13547.125     -13547.125      270.91185      270.91185      31300.733      31300.733      112.48923      112.48923    
Loop time of 116.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.743 ns/day, 32.280 hours/ns, 8.605 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.69     | 115.69     | 115.69     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096023   | 0.096023   | 0.096023   |   0.0 |  0.08
Output  | 0.00016737 | 0.00016737 | 0.00016737 |   0.0 |  0.00
Modify  | 0.36459    | 0.36459    | 0.36459    |   0.0 |  0.31
Other   |            | 0.05827    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.885404258987, Press = -0.240204823304921
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -13477.123     -13477.123     -13547.125     -13547.125      270.91185      270.91185      31300.733      31300.733      112.48923      112.48923    
     95000  -13481.659     -13481.659     -13549.725     -13549.725      263.42335      263.42335      31284.176      31284.176      1077.9419      1077.9419    
Loop time of 133.704 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.140 hours/ns, 7.479 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    | 133.08     | 133.08     | 133.08     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10945    | 0.10945    | 0.10945    |   0.0 |  0.08
Output  | 0.00016839 | 0.00016839 | 0.00016839 |   0.0 |  0.00
Modify  | 0.44846    | 0.44846    | 0.44846    |   0.0 |  0.34
Other   |            | 0.0662     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.869744697923, Press = -0.251860086755471
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -13481.659     -13481.659     -13549.725     -13549.725      263.42335      263.42335      31284.176      31284.176      1077.9419      1077.9419    
     96000  -13476.564     -13476.564     -13545.563     -13545.563      267.0308       267.0308       31265.822      31265.822      3220.7758      3220.7758    
Loop time of 121.792 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.831 hours/ns, 8.211 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.24     | 121.24     | 121.24     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099689   | 0.099689   | 0.099689   |   0.0 |  0.08
Output  | 0.0001698  | 0.0001698  | 0.0001698  |   0.0 |  0.00
Modify  | 0.39296    | 0.39296    | 0.39296    |   0.0 |  0.32
Other   |            | 0.06178    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.858411139773, Press = -0.155020331738912
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -13476.564     -13476.564     -13545.563     -13545.563      267.0308       267.0308       31265.822      31265.822      3220.7758      3220.7758    
     97000  -13479.945     -13479.945     -13548.753     -13548.753      266.29349      266.29349      31257.17       31257.17       3713.1413      3713.1413    
Loop time of 128.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.803 hours/ns, 7.759 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.29     | 128.29     | 128.29     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10776    | 0.10776    | 0.10776    |   0.0 |  0.08
Output  | 0.00016757 | 0.00016757 | 0.00016757 |   0.0 |  0.00
Modify  | 0.4265     | 0.4265     | 0.4265     |   0.0 |  0.33
Other   |            | 0.06241    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.84249684431, Press = 0.175834495171699
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -13479.945     -13479.945     -13548.753     -13548.753      266.29349      266.29349      31257.17       31257.17       3713.1413      3713.1413    
     98000  -13476.601     -13476.601     -13547.088     -13547.088      272.7903       272.7903       31275.844      31275.844      2272.2768      2272.2768    
Loop time of 132.354 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.74     | 131.74     | 131.74     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10778    | 0.10778    | 0.10778    |   0.0 |  0.08
Output  | 0.0002188  | 0.0002188  | 0.0002188  |   0.0 |  0.00
Modify  | 0.44407    | 0.44407    | 0.44407    |   0.0 |  0.34
Other   |            | 0.06507    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.84130923456, Press = 0.264946314261148
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -13476.601     -13476.601     -13547.088     -13547.088      272.7903       272.7903       31275.844      31275.844      2272.2768      2272.2768    
     99000  -13478.472     -13478.472     -13548.888     -13548.888      272.52004      272.52004      31283.774      31283.774      1294.512       1294.512     
Loop time of 123.002 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.167 hours/ns, 8.130 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.44     | 122.44     | 122.44     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10233    | 0.10233    | 0.10233    |   0.0 |  0.08
Output  | 0.00016729 | 0.00016729 | 0.00016729 |   0.0 |  0.00
Modify  | 0.39886    | 0.39886    | 0.39886    |   0.0 |  0.32
Other   |            | 0.06156    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.847749329746, Press = 0.12639397920577
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -13478.472     -13478.472     -13548.888     -13548.888      272.52004      272.52004      31283.774      31283.774      1294.512       1294.512     
    100000  -13478.037     -13478.037     -13548.717     -13548.717      273.54         273.54         31291.991      31291.991      584.91463      584.91463    
Loop time of 129.536 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 35.982 hours/ns, 7.720 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.94     | 128.94     | 128.94     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1064     | 0.1064     | 0.1064     |   0.0 |  0.08
Output  | 0.00044714 | 0.00044714 | 0.00044714 |   0.0 |  0.00
Modify  | 0.42836    | 0.42836    | 0.42836    |   0.0 |  0.33
Other   |            | 0.06389    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.855102867092, Press = 0.0720442584881425
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -13478.037     -13478.037     -13548.717     -13548.717      273.54         273.54         31291.991      31291.991      584.91463      584.91463    
    101000  -13481.358     -13481.358     -13551.051     -13551.051      269.71921      269.71921      31292.696      31292.696      214.35154      214.35154    
Loop time of 133.495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.082 hours/ns, 7.491 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.87     | 132.87     | 132.87     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1107     | 0.1107     | 0.1107     |   0.0 |  0.08
Output  | 0.00020089 | 0.00020089 | 0.00020089 |   0.0 |  0.00
Modify  | 0.44633    | 0.44633    | 0.44633    |   0.0 |  0.33
Other   |            | 0.06467    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.856292585873, Press = -0.0401676001102631
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -13481.358     -13481.358     -13551.051     -13551.051      269.71921      269.71921      31292.696      31292.696      214.35154      214.35154    
    102000  -13476.92      -13476.92      -13545.896     -13545.896      266.94279      266.94279      31295.964      31295.964      709.28727      709.28727    
Loop time of 136.309 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.634 ns/day, 37.864 hours/ns, 7.336 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.66     | 135.66     | 135.66     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12342    | 0.12342    | 0.12342    |   0.0 |  0.09
Output  | 0.00023543 | 0.00023543 | 0.00023543 |   0.0 |  0.00
Modify  | 0.46795    | 0.46795    | 0.46795    |   0.0 |  0.34
Other   |            | 0.06212    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.833576061784, Press = -0.0576726449755553
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -13476.92      -13476.92      -13545.896     -13545.896      266.94279      266.94279      31295.964      31295.964      709.28727      709.28727    
    103000  -13481.253     -13481.253     -13550.213     -13550.213      266.88185      266.88185      31288.08       31288.08       684.8864       684.8864     
Loop time of 132.893 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.915 hours/ns, 7.525 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    | 132.27     | 132.27     | 132.27     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1085     | 0.1085     | 0.1085     |   0.0 |  0.08
Output  | 0.00017191 | 0.00017191 | 0.00017191 |   0.0 |  0.00
Modify  | 0.44458    | 0.44458    | 0.44458    |   0.0 |  0.33
Other   |            | 0.06526    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.818378666355, Press = -0.174174723140773
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -13481.253     -13481.253     -13550.213     -13550.213      266.88185      266.88185      31288.08       31288.08       684.8864       684.8864     
    104000  -13476.758     -13476.758     -13548.794     -13548.794      278.78809      278.78809      31266.008      31266.008      2774.016       2774.016     
Loop time of 134.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.252 hours/ns, 7.457 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.48     | 133.48     | 133.48     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11044    | 0.11044    | 0.11044    |   0.0 |  0.08
Output  | 0.00020915 | 0.00020915 | 0.00020915 |   0.0 |  0.00
Modify  | 0.44901    | 0.44901    | 0.44901    |   0.0 |  0.33
Other   |            | 0.06634    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.805185633537, Press = -0.242030014713737
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -13476.758     -13476.758     -13548.794     -13548.794      278.78809      278.78809      31266.008      31266.008      2774.016       2774.016     
    105000  -13480.733     -13480.733     -13550.393     -13550.393      269.59268      269.59268      31250.394      31250.394      3685.9902      3685.9902    
Loop time of 132.684 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.857 hours/ns, 7.537 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    | 132.06     | 132.06     | 132.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10899    | 0.10899    | 0.10899    |   0.0 |  0.08
Output  | 0.00016986 | 0.00016986 | 0.00016986 |   0.0 |  0.00
Modify  | 0.44408    | 0.44408    | 0.44408    |   0.0 |  0.33
Other   |            | 0.06591    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.783661284159, Press = 0.0764741434498035
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -13480.733     -13480.733     -13550.393     -13550.393      269.59268      269.59268      31250.394      31250.394      3685.9902      3685.9902    
    106000  -13477.898     -13477.898     -13547.577     -13547.577      269.66265      269.66265      31272.126      31272.126      2381.5776      2381.5776    
Loop time of 134.319 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.311 hours/ns, 7.445 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.69     | 133.69     | 133.69     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10998    | 0.10998    | 0.10998    |   0.0 |  0.08
Output  | 0.00019938 | 0.00019938 | 0.00019938 |   0.0 |  0.00
Modify  | 0.45624    | 0.45624    | 0.45624    |   0.0 |  0.34
Other   |            | 0.06745    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.77462750319, Press = 0.25912602309162
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -13477.898     -13477.898     -13547.577     -13547.577      269.66265      269.66265      31272.126      31272.126      2381.5776      2381.5776    
    107000  -13474.952     -13474.952     -13544.532     -13544.532      269.28213      269.28213      31290.54       31290.54       1276.3759      1276.3759    
Loop time of 131.725 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.590 hours/ns, 7.592 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.11     | 131.11     | 131.11     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10667    | 0.10667    | 0.10667    |   0.0 |  0.08
Output  | 0.00021254 | 0.00021254 | 0.00021254 |   0.0 |  0.00
Modify  | 0.43925    | 0.43925    | 0.43925    |   0.0 |  0.33
Other   |            | 0.06503    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.786049091236, Press = 0.279211718232058
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -13474.952     -13474.952     -13544.532     -13544.532      269.28213      269.28213      31290.54       31290.54       1276.3759      1276.3759    
    108000  -13477.739     -13477.739     -13545.346     -13545.346      261.64552      261.64552      31298.184      31298.184      382.23497      382.23497    
Loop time of 135.779 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.716 hours/ns, 7.365 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.13     | 135.13     | 135.13     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12173    | 0.12173    | 0.12173    |   0.0 |  0.09
Output  | 0.00032871 | 0.00032871 | 0.00032871 |   0.0 |  0.00
Modify  | 0.46587    | 0.46587    | 0.46587    |   0.0 |  0.34
Other   |            | 0.06347    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.789497523632, Press = 0.20857878514001
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -13477.739     -13477.739     -13545.346     -13545.346      261.64552      261.64552      31298.184      31298.184      382.23497      382.23497    
    109000  -13475.364     -13475.364     -13545.464     -13545.464      271.29454      271.29454      31306.148      31306.148     -56.080365     -56.080365    
Loop time of 135.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.646 hours/ns, 7.379 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    | 134.87     | 134.87     | 134.87     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12321    | 0.12321    | 0.12321    |   0.0 |  0.09
Output  | 0.00023629 | 0.00023629 | 0.00023629 |   0.0 |  0.00
Modify  | 0.46487    | 0.46487    | 0.46487    |   0.0 |  0.34
Other   |            | 0.0638     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.817297577476, Press = 0.0467289670387872
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -13475.364     -13475.364     -13545.464     -13545.464      271.29454      271.29454      31306.148      31306.148     -56.080365     -56.080365    
    110000  -13479.607     -13479.607     -13549.322     -13549.322      269.80674      269.80674      31302.797      31302.797     -289.95996     -289.95996    
Loop time of 129.833 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.065 hours/ns, 7.702 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.23     | 129.23     | 129.23     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11062    | 0.11062    | 0.11062    |   0.0 |  0.09
Output  | 0.00016778 | 0.00016778 | 0.00016778 |   0.0 |  0.00
Modify  | 0.43129    | 0.43129    | 0.43129    |   0.0 |  0.33
Other   |            | 0.06337    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.814499724443, Press = -0.0879312809948695
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -13479.607     -13479.607     -13549.322     -13549.322      269.80674      269.80674      31302.797      31302.797     -289.95996     -289.95996    
    111000  -13476.377     -13476.377     -13547.471     -13547.471      275.14316      275.14316      31302.014      31302.014     -47.730826     -47.730826    
Loop time of 118.212 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.837 hours/ns, 8.459 timesteps/s
100.0% 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.68     | 117.68     | 117.68     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097748   | 0.097748   | 0.097748   |   0.0 |  0.08
Output  | 0.00017068 | 0.00017068 | 0.00017068 |   0.0 |  0.00
Modify  | 0.37627    | 0.37627    | 0.37627    |   0.0 |  0.32
Other   |            | 0.05948    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.810598859561, Press = -0.139154912453848
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -13476.377     -13476.377     -13547.471     -13547.471      275.14316      275.14316      31302.014      31302.014     -47.730826     -47.730826    
    112000  -13478.195     -13478.195     -13549.316     -13549.316      275.24395      275.24395      31302.282      31302.282     -312.49501     -312.49501    
Loop time of 115.512 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.748 ns/day, 32.087 hours/ns, 8.657 timesteps/s
100.0% 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        | 115        | 115        |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0961     | 0.0961     | 0.0961     |   0.0 |  0.08
Output  | 0.00019859 | 0.00019859 | 0.00019859 |   0.0 |  0.00
Modify  | 0.36137    | 0.36137    | 0.36137    |   0.0 |  0.31
Other   |            | 0.05751    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.784666820684, Press = -0.132226435903645
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -13478.195     -13478.195     -13549.316     -13549.316      275.24395      275.24395      31302.282      31302.282     -312.49501     -312.49501    
    113000  -13476.121     -13476.121     -13545.956     -13545.956      270.27097      270.27097      31299.689      31299.689      344.59999      344.59999    
Loop time of 133.551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.097 hours/ns, 7.488 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.93     | 132.93     | 132.93     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10872    | 0.10872    | 0.10872    |   0.0 |  0.08
Output  | 0.00016821 | 0.00016821 | 0.00016821 |   0.0 |  0.00
Modify  | 0.44669    | 0.44669    | 0.44669    |   0.0 |  0.33
Other   |            | 0.06543    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.788638854071, Press = -0.279180855852602
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -13476.121     -13476.121     -13545.956     -13545.956      270.27097      270.27097      31299.689      31299.689      344.59999      344.59999    
    114000  -13477.517     -13477.517     -13548.927     -13548.927      276.36389      276.36389      31300.141      31300.141      13.165795      13.165795    
Loop time of 121.93 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.869 hours/ns, 8.201 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.37     | 121.37     | 121.37     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10073    | 0.10073    | 0.10073    |   0.0 |  0.08
Output  | 0.00020739 | 0.00020739 | 0.00020739 |   0.0 |  0.00
Modify  | 0.39322    | 0.39322    | 0.39322    |   0.0 |  0.32
Other   |            | 0.0609     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.802105325025, Press = -0.452944512043594
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -13477.517     -13477.517     -13548.927     -13548.927      276.36389      276.36389      31300.141      31300.141      13.165795      13.165795    
    115000  -13476.646     -13476.646     -13548.803     -13548.803      279.25398      279.25398      31285.045      31285.045      1275.6703      1275.6703    
Loop time of 134.098 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.249 hours/ns, 7.457 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    | 133.47     | 133.47     | 133.47     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10977    | 0.10977    | 0.10977    |   0.0 |  0.08
Output  | 0.0002304  | 0.0002304  | 0.0002304  |   0.0 |  0.00
Modify  | 0.45113    | 0.45113    | 0.45113    |   0.0 |  0.34
Other   |            | 0.06561    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.8319741551, Press = -0.623479225210439
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -13476.646     -13476.646     -13548.803     -13548.803      279.25398      279.25398      31285.045      31285.045      1275.6703      1275.6703    
    116000  -13478.414     -13478.414     -13547.645     -13547.645      267.92866      267.92866      31271.595      31271.595      2465.391       2465.391     
Loop time of 126.05 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.685 ns/day, 35.014 hours/ns, 7.933 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    | 125.47     | 125.47     | 125.47     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10453    | 0.10453    | 0.10453    |   0.0 |  0.08
Output  | 0.00020214 | 0.00020214 | 0.00020214 |   0.0 |  0.00
Modify  | 0.41236    | 0.41236    | 0.41236    |   0.0 |  0.33
Other   |            | 0.06217    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.83210136629, Press = -0.49742798272514
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -13478.414     -13478.414     -13547.645     -13547.645      267.92866      267.92866      31271.595      31271.595      2465.391       2465.391     
    117000  -13477.361     -13477.361     -13548.397     -13548.397      274.91732      274.91732      31284.996      31284.996      1240.9357      1240.9357    
Loop time of 121.843 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.845 hours/ns, 8.207 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.29     | 121.29     | 121.29     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099948   | 0.099948   | 0.099948   |   0.0 |  0.08
Output  | 0.00023945 | 0.00023945 | 0.00023945 |   0.0 |  0.00
Modify  | 0.39242    | 0.39242    | 0.39242    |   0.0 |  0.32
Other   |            | 0.06189    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.836077477649, Press = -0.211160819032581
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -13477.361     -13477.361     -13548.397     -13548.397      274.91732      274.91732      31284.996      31284.996      1240.9357      1240.9357    
    118000  -13477.118     -13477.118     -13549.102     -13549.102      278.58548      278.58548      31290.916      31290.916      744.56014      744.56014    
Loop time of 116.466 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.742 ns/day, 32.352 hours/ns, 8.586 timesteps/s
100.0% 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 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095627   | 0.095627   | 0.095627   |   0.0 |  0.08
Output  | 0.00016788 | 0.00016788 | 0.00016788 |   0.0 |  0.00
Modify  | 0.36772    | 0.36772    | 0.36772    |   0.0 |  0.32
Other   |            | 0.06031    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.830972496092, Press = -0.0171454795611764
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -13477.118     -13477.118     -13549.102     -13549.102      278.58548      278.58548      31290.916      31290.916      744.56014      744.56014    
    119000  -13477.8       -13477.8       -13546.929     -13546.929      267.53537      267.53537      31283.852      31283.852      1520.2784      1520.2784    
Loop time of 118.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.729 ns/day, 32.916 hours/ns, 8.439 timesteps/s
100.0% 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.96     | 117.96     | 117.96     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096858   | 0.096858   | 0.096858   |   0.0 |  0.08
Output  | 0.0001695  | 0.0001695  | 0.0001695  |   0.0 |  0.00
Modify  | 0.37654    | 0.37654    | 0.37654    |   0.0 |  0.32
Other   |            | 0.06122    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.840484578224, Press = 0.0797941873702132
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -13477.8       -13477.8       -13546.929     -13546.929      267.53537      267.53537      31283.852      31283.852      1520.2784      1520.2784    
    120000  -13475.706     -13475.706     -13544.326     -13544.326      265.56632      265.56632      31285.414      31285.414      1889.2539      1889.2539    
Loop time of 133.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.188 hours/ns, 7.469 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.26     | 133.26     | 133.26     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10806    | 0.10806    | 0.10806    |   0.0 |  0.08
Output  | 0.00021143 | 0.00021143 | 0.00021143 |   0.0 |  0.00
Modify  | 0.44716    | 0.44716    | 0.44716    |   0.0 |  0.33
Other   |            | 0.06732    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.854489355315, Press = 0.352128288536484
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -13475.706     -13475.706     -13544.326     -13544.326      265.56632      265.56632      31285.414      31285.414      1889.2539      1889.2539    
    121000  -13479.199     -13479.199     -13548.053     -13548.053      266.47186      266.47186      31297.483      31297.483      158.93883      158.93883    
Loop time of 133.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.054 hours/ns, 7.497 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    | 132.77     | 132.77     | 132.77     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10807    | 0.10807    | 0.10807    |   0.0 |  0.08
Output  | 0.00023123 | 0.00023123 | 0.00023123 |   0.0 |  0.00
Modify  | 0.44784    | 0.44784    | 0.44784    |   0.0 |  0.34
Other   |            | 0.0675     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.875317292179, Press = 0.669723837955038
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -13479.199     -13479.199     -13548.053     -13548.053      266.47186      266.47186      31297.483      31297.483      158.93883      158.93883    
    122000  -13477.996     -13477.996     -13548.532     -13548.532      272.98136      272.98136      31318.043      31318.043     -1481.6393     -1481.6393    
Loop time of 120.681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.522 hours/ns, 8.286 timesteps/s
100.0% 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.13     | 120.13     | 120.13     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098911   | 0.098911   | 0.098911   |   0.0 |  0.08
Output  | 0.00016642 | 0.00016642 | 0.00016642 |   0.0 |  0.00
Modify  | 0.38747    | 0.38747    | 0.38747    |   0.0 |  0.32
Other   |            | 0.06083    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.879714486542, Press = 0.211080150814368
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -13477.996     -13477.996     -13548.532     -13548.532      272.98136      272.98136      31318.043      31318.043     -1481.6393     -1481.6393    
    123000  -13477.763     -13477.763     -13548.703     -13548.703      274.54446      274.54446      31312.791      31312.791     -1147.6455     -1147.6455    
Loop time of 125.626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.896 hours/ns, 7.960 timesteps/s
100.0% 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.05     | 125.05     | 125.05     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1025     | 0.1025     | 0.1025     |   0.0 |  0.08
Output  | 0.00021547 | 0.00021547 | 0.00021547 |   0.0 |  0.00
Modify  | 0.41085    | 0.41085    | 0.41085    |   0.0 |  0.33
Other   |            | 0.06136    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857605915848, Press = 0.0175268209553549
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -13477.763     -13477.763     -13548.703     -13548.703      274.54446      274.54446      31312.791      31312.791     -1147.6455     -1147.6455    
    124000  -13478.755     -13478.755     -13549.971     -13549.971      275.61448      275.61448      31321.304      31321.304     -1957.4275     -1957.4275    
Loop time of 125.375 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.689 ns/day, 34.826 hours/ns, 7.976 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.8      | 124.8      | 124.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10379    | 0.10379    | 0.10379    |   0.0 |  0.08
Output  | 0.00016695 | 0.00016695 | 0.00016695 |   0.0 |  0.00
Modify  | 0.41071    | 0.41071    | 0.41071    |   0.0 |  0.33
Other   |            | 0.0625     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.848350564435, Press = -0.145095710462124
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -13478.755     -13478.755     -13549.971     -13549.971      275.61448      275.61448      31321.304      31321.304     -1957.4275     -1957.4275    
    125000  -13475.273     -13475.273     -13546.178     -13546.178      274.40915      274.40915      31326.079      31326.079     -1802.8748     -1802.8748    
Loop time of 115.598 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.111 hours/ns, 8.651 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.08     | 115.08     | 115.08     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09544    | 0.09544    | 0.09544    |   0.0 |  0.08
Output  | 0.00020461 | 0.00020461 | 0.00020461 |   0.0 |  0.00
Modify  | 0.36473    | 0.36473    | 0.36473    |   0.0 |  0.32
Other   |            | 0.05801    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.835372165965, Press = -0.243041689234479
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -13475.273     -13475.273     -13546.178     -13546.178      274.40915      274.40915      31326.079      31326.079     -1802.8748     -1802.8748    
    126000  -13477.007     -13477.007     -13548.935     -13548.935      278.36975      278.36975      31342.598      31342.598     -3706.9489     -3706.9489    
Loop time of 115.149 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.750 ns/day, 31.986 hours/ns, 8.684 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.63     | 114.63     | 114.63     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096353   | 0.096353   | 0.096353   |   0.0 |  0.08
Output  | 0.00017072 | 0.00017072 | 0.00017072 |   0.0 |  0.00
Modify  | 0.3627     | 0.3627     | 0.3627     |   0.0 |  0.31
Other   |            | 0.0576     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.839048857348, Press = -0.685947039063754
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -13477.007     -13477.007     -13548.935     -13548.935      278.36975      278.36975      31342.598      31342.598     -3706.9489     -3706.9489    
    127000  -13477.283     -13477.283     -13548.841     -13548.841      276.93907      276.93907      31311.813      31311.813     -977.17011     -977.17011    
Loop time of 123.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.168 hours/ns, 8.130 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.44     | 122.44     | 122.44     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10292    | 0.10292    | 0.10292    |   0.0 |  0.08
Output  | 0.0001719  | 0.0001719  | 0.0001719  |   0.0 |  0.00
Modify  | 0.40057    | 0.40057    | 0.40057    |   0.0 |  0.33
Other   |            | 0.06073    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.859747743181, Press = -0.521103529208757
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -13477.283     -13477.283     -13548.841     -13548.841      276.93907      276.93907      31311.813      31311.813     -977.17011     -977.17011    
    128000  -13478.98      -13478.98      -13548.229     -13548.229      268.00031      268.00031      31294.036      31294.036      398.72806      398.72806    
Loop time of 129.773 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.048 hours/ns, 7.706 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.17     | 129.17     | 129.17     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10621    | 0.10621    | 0.10621    |   0.0 |  0.08
Output  | 0.00016901 | 0.00016901 | 0.00016901 |   0.0 |  0.00
Modify  | 0.43163    | 0.43163    | 0.43163    |   0.0 |  0.33
Other   |            | 0.0647     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.876055093886, Press = -0.186882316157037
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -13478.98      -13478.98      -13548.229     -13548.229      268.00031      268.00031      31294.036      31294.036      398.72806      398.72806    
    129000  -13474.895     -13474.895     -13547.154     -13547.154      279.65045      279.65045      31294.811      31294.811      595.65494      595.65494    
Loop time of 134.191 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.275 hours/ns, 7.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.57     | 133.57     | 133.57     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10798    | 0.10798    | 0.10798    |   0.0 |  0.08
Output  | 0.00021283 | 0.00021283 | 0.00021283 |   0.0 |  0.00
Modify  | 0.45056    | 0.45056    | 0.45056    |   0.0 |  0.34
Other   |            | 0.06553    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.896406541088, Press = -0.0921612927466741
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -13474.895     -13474.895     -13547.154     -13547.154      279.65045      279.65045      31294.811      31294.811      595.65494      595.65494    
    130000  -13474.731     -13474.731     -13547.166     -13547.166      280.33106      280.33106      31292.383      31292.383      973.83117      973.83117    
Loop time of 131.103 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.417 hours/ns, 7.628 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    | 130.5      | 130.5      | 130.5      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10613    | 0.10613    | 0.10613    |   0.0 |  0.08
Output  | 0.00024803 | 0.00024803 | 0.00024803 |   0.0 |  0.00
Modify  | 0.43379    | 0.43379    | 0.43379    |   0.0 |  0.33
Other   |            | 0.06435    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.900469884129, Press = -0.0488684755400252
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -13474.731     -13474.731     -13547.166     -13547.166      280.33106      280.33106      31292.383      31292.383      973.83117      973.83117    
    131000  -13478.008     -13478.008     -13547.926     -13547.926      270.59288      270.59288      31283.123      31283.123      1521.2834      1521.2834    
Loop time of 131.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.570 hours/ns, 7.596 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.04     | 131.04     | 131.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10638    | 0.10638    | 0.10638    |   0.0 |  0.08
Output  | 0.0002484  | 0.0002484  | 0.0002484  |   0.0 |  0.00
Modify  | 0.43836    | 0.43836    | 0.43836    |   0.0 |  0.33
Other   |            | 0.06459    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.903202354164, Press = 0.125201879775732
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -13478.008     -13478.008     -13547.926     -13547.926      270.59288      270.59288      31283.123      31283.123      1521.2834      1521.2834    
    132000  -13476.795     -13476.795     -13547.565     -13547.565      273.88713      273.88713      31291.078      31291.078      841.31562      841.31562    
Loop time of 133.902 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.195 hours/ns, 7.468 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.28     | 133.28     | 133.28     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10851    | 0.10851    | 0.10851    |   0.0 |  0.08
Output  | 0.00021441 | 0.00021441 | 0.00021441 |   0.0 |  0.00
Modify  | 0.44673    | 0.44673    | 0.44673    |   0.0 |  0.33
Other   |            | 0.06488    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.904868027596, Press = 0.328695533217731
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -13476.795     -13476.795     -13547.565     -13547.565      273.88713      273.88713      31291.078      31291.078      841.31562      841.31562    
    133000  -13480.573     -13480.573     -13547.755     -13547.755      260.00166      260.00166      31293.458      31293.458      650.55671      650.55671    
Loop time of 133.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.219 hours/ns, 7.463 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.36     | 133.36     | 133.36     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10835    | 0.10835    | 0.10835    |   0.0 |  0.08
Output  | 0.00021315 | 0.00021315 | 0.00021315 |   0.0 |  0.00
Modify  | 0.44865    | 0.44865    | 0.44865    |   0.0 |  0.33
Other   |            | 0.06517    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.888557121757, Press = 0.398396278102998
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -13480.573     -13480.573     -13547.755     -13547.755      260.00166      260.00166      31293.458      31293.458      650.55671      650.55671    
    134000  -13475.557     -13475.557     -13545.856     -13545.856      272.06236      272.06236      31306.298      31306.298     -54.539454     -54.539454    
Loop time of 133.142 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.984 hours/ns, 7.511 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.52     | 132.52     | 132.52     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10773    | 0.10773    | 0.10773    |   0.0 |  0.08
Output  | 0.00021088 | 0.00021088 | 0.00021088 |   0.0 |  0.00
Modify  | 0.44665    | 0.44665    | 0.44665    |   0.0 |  0.34
Other   |            | 0.06489    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.884309870993, Press = 0.267783275244017
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -13475.557     -13475.557     -13545.856     -13545.856      272.06236      272.06236      31306.298      31306.298     -54.539454     -54.539454    
    135000  -13478.617     -13478.617     -13547.903     -13547.903      268.14261      268.14261      31306.638      31306.638     -397.09697     -397.09697    
Loop time of 128.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.673 ns/day, 35.671 hours/ns, 7.787 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.82     | 127.82     | 127.82     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10406    | 0.10406    | 0.10406    |   0.0 |  0.08
Output  | 0.00017301 | 0.00017301 | 0.00017301 |   0.0 |  0.00
Modify  | 0.42357    | 0.42357    | 0.42357    |   0.0 |  0.33
Other   |            | 0.06408    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.870969579041, Press = 0.0751635538922738
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -13478.617     -13478.617     -13547.903     -13547.903      268.14261      268.14261      31306.638      31306.638     -397.09697     -397.09697    
    136000  -13475.751     -13475.751     -13546.938     -13546.938      275.50032      275.50032      31317.498      31317.498     -1102.5852     -1102.5852    
Loop time of 134.234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.287 hours/ns, 7.450 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.61     | 133.61     | 133.61     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10894    | 0.10894    | 0.10894    |   0.0 |  0.08
Output  | 0.0002033  | 0.0002033  | 0.0002033  |   0.0 |  0.00
Modify  | 0.45083    | 0.45083    | 0.45083    |   0.0 |  0.34
Other   |            | 0.06507    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.864748308145, Press = -0.0127840173772447
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -13475.751     -13475.751     -13546.938     -13546.938      275.50032      275.50032      31317.498      31317.498     -1102.5852     -1102.5852    
    137000  -13480.04      -13480.04      -13550.129     -13550.129      271.25165      271.25165      31328.327      31328.327     -2530.3335     -2530.3335    
Loop time of 126.381 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.106 hours/ns, 7.913 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.8      | 125.8      | 125.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10296    | 0.10296    | 0.10296    |   0.0 |  0.08
Output  | 0.00021537 | 0.00021537 | 0.00021537 |   0.0 |  0.00
Modify  | 0.41489    | 0.41489    | 0.41489    |   0.0 |  0.33
Other   |            | 0.06346    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.85331398601, Press = -0.105097589770627
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -13480.04      -13480.04      -13550.129     -13550.129      271.25165      271.25165      31328.327      31328.327     -2530.3335     -2530.3335    
    138000  -13476.719     -13476.719     -13546.9       -13546.9        271.60942      271.60942      31340.209      31340.209     -3118.7694     -3118.7694    
Loop time of 133.667 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.130 hours/ns, 7.481 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.04     | 133.04     | 133.04     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11212    | 0.11212    | 0.11212    |   0.0 |  0.08
Output  | 0.00025598 | 0.00025598 | 0.00025598 |   0.0 |  0.00
Modify  | 0.44681    | 0.44681    | 0.44681    |   0.0 |  0.33
Other   |            | 0.06497    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.850271445408, Press = -0.346191899190823
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -13476.719     -13476.719     -13546.9       -13546.9        271.60942      271.60942      31340.209      31340.209     -3118.7694     -3118.7694    
    139000  -13478.288     -13478.288     -13547.248     -13547.248      266.88011      266.88011      31322.001      31322.001     -1796.2355     -1796.2355    
Loop time of 133.683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.134 hours/ns, 7.480 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.06     | 133.06     | 133.06     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10851    | 0.10851    | 0.10851    |   0.0 |  0.08
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.44633    | 0.44633    | 0.44633    |   0.0 |  0.33
Other   |            | 0.06469    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.84926688615, Press = -0.397966664449842
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -13478.288     -13478.288     -13547.248     -13547.248      266.88011      266.88011      31322.001      31322.001     -1796.2355     -1796.2355    
    140000  -13474.914     -13474.914     -13547.799     -13547.799      282.07248      282.07248      31310.38       31310.38      -725.52682     -725.52682    
Loop time of 132.706 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.863 hours/ns, 7.535 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.09     | 132.09     | 132.09     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10785    | 0.10785    | 0.10785    |   0.0 |  0.08
Output  | 0.00021307 | 0.00021307 | 0.00021307 |   0.0 |  0.00
Modify  | 0.44615    | 0.44615    | 0.44615    |   0.0 |  0.34
Other   |            | 0.06558    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.85443886638, Press = -0.18213620728658
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -13474.914     -13474.914     -13547.799     -13547.799      282.07248      282.07248      31310.38       31310.38      -725.52682     -725.52682    
    141000  -13478.24      -13478.24      -13548.857     -13548.857      273.29726      273.29726      31301.858      31301.858     -238.22844     -238.22844    
Loop time of 134.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.645 ns/day, 37.225 hours/ns, 7.462 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.39     | 133.39     | 133.39     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10817    | 0.10817    | 0.10817    |   0.0 |  0.08
Output  | 0.00021356 | 0.00021356 | 0.00021356 |   0.0 |  0.00
Modify  | 0.44874    | 0.44874    | 0.44874    |   0.0 |  0.33
Other   |            | 0.0661     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.865287221159, Press = -0.186495197267702
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -13478.24      -13478.24      -13548.857     -13548.857      273.29726      273.29726      31301.858      31301.858     -238.22844     -238.22844    
    142000  -13474.725     -13474.725     -13545.496     -13545.496      273.88911      273.88911      31309.007      31309.007     -310.69181     -310.69181    
Loop time of 130.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.361 hours/ns, 7.639 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    | 130.29     | 130.29     | 130.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10879    | 0.10879    | 0.10879    |   0.0 |  0.08
Output  | 0.0002116  | 0.0002116  | 0.0002116  |   0.0 |  0.00
Modify  | 0.43777    | 0.43777    | 0.43777    |   0.0 |  0.33
Other   |            | 0.06333    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.874389715453, Press = -0.246847136584556
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -13474.725     -13474.725     -13545.496     -13545.496      273.88911      273.88911      31309.007      31309.007     -310.69181     -310.69181    
    143000  -13479.919     -13479.919     -13547.948     -13547.948      263.27882      263.27882      31322.322      31322.322     -1783.9705     -1783.9705    
Loop time of 132.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.812 hours/ns, 7.546 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.9      | 131.9      | 131.9      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10954    | 0.10954    | 0.10954    |   0.0 |  0.08
Output  | 0.00016934 | 0.00016934 | 0.00016934 |   0.0 |  0.00
Modify  | 0.44918    | 0.44918    | 0.44918    |   0.0 |  0.34
Other   |            | 0.06491    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.876745345445, Press = -0.417971887081125
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -13479.919     -13479.919     -13547.948     -13547.948      263.27882      263.27882      31322.322      31322.322     -1783.9705     -1783.9705    
    144000  -13477.022     -13477.022     -13546.281     -13546.281      268.0395       268.0395       31317.603      31317.603     -1234.7834     -1234.7834    
Loop time of 116.778 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.740 ns/day, 32.438 hours/ns, 8.563 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.25     | 116.25     | 116.25     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09595    | 0.09595    | 0.09595    |   0.0 |  0.08
Output  | 0.00017036 | 0.00017036 | 0.00017036 |   0.0 |  0.00
Modify  | 0.36993    | 0.36993    | 0.36993    |   0.0 |  0.32
Other   |            | 0.05921    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.860076494958, Press = -0.527530005307113
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -13477.022     -13477.022     -13546.281     -13546.281      268.0395       268.0395       31317.603      31317.603     -1234.7834     -1234.7834    
    145000  -13478.846     -13478.846     -13547.205     -13547.205      264.55465      264.55465      31303.831      31303.831     -307.01256     -307.01256    
Loop time of 131.461 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.657 ns/day, 36.517 hours/ns, 7.607 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    | 130.84     | 130.84     | 130.84     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10872    | 0.10872    | 0.10872    |   0.0 |  0.08
Output  | 0.00031644 | 0.00031644 | 0.00031644 |   0.0 |  0.00
Modify  | 0.44247    | 0.44247    | 0.44247    |   0.0 |  0.34
Other   |            | 0.06483    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.864268575614, Press = -0.388867361302696
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -13478.846     -13478.846     -13547.205     -13547.205      264.55465      264.55465      31303.831      31303.831     -307.01256     -307.01256    
    146000  -13475.519     -13475.519     -13548.24      -13548.24       281.43604      281.43604      31305.304      31305.304     -437.04785     -437.04785    
Loop time of 132.584 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.829 hours/ns, 7.542 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.97     | 131.97     | 131.97     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10708    | 0.10708    | 0.10708    |   0.0 |  0.08
Output  | 0.00017075 | 0.00017075 | 0.00017075 |   0.0 |  0.00
Modify  | 0.44459    | 0.44459    | 0.44459    |   0.0 |  0.34
Other   |            | 0.0646     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127986 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.878449816808, Press = -0.25119014207632
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    146000  -13475.519     -13475.519     -13548.24      -13548.24       281.43604      281.43604      31305.304      31305.304     -437.04785     -437.04785    
    147000  -13479.89      -13479.89      -13548.752     -13548.752      266.50511      266.50511      31303.187      31303.187     -371.28671     -371.28671    
Loop time of 131.223 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.61     | 130.61     | 130.61     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10711    | 0.10711    | 0.10711    |   0.0 |  0.08
Output  | 0.00017342 | 0.00017342 | 0.00017342 |   0.0 |  0.00
Modify  | 0.43801    | 0.43801    | 0.43801    |   0.0 |  0.33
Other   |            | 0.06485    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.877220728256, Press = -0.179451908306187
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    147000  -13479.89      -13479.89      -13548.752     -13548.752      266.50511      266.50511      31303.187      31303.187     -371.28671     -371.28671    
    148000  -13478.872     -13478.872     -13548.135     -13548.135      268.055        268.055        31304.592      31304.592     -292.68047     -292.68047    
Loop time of 127.068 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.297 hours/ns, 7.870 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.48     | 126.48     | 126.48     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10489    | 0.10489    | 0.10489    |   0.0 |  0.08
Output  | 0.00016769 | 0.00016769 | 0.00016769 |   0.0 |  0.00
Modify  | 0.41702    | 0.41702    | 0.41702    |   0.0 |  0.33
Other   |            | 0.06229    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.875200840412, Press = -0.165957831133632
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    148000  -13478.872     -13478.872     -13548.135     -13548.135      268.055        268.055        31304.592      31304.592     -292.68047     -292.68047    
    149000  -13476.83      -13476.83      -13549.571     -13549.571      281.51442      281.51442      31302.794      31302.794     -324.718       -324.718      
Loop time of 114.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.748 hours/ns, 8.749 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.78     | 113.78     | 113.78     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094082   | 0.094082   | 0.094082   |   0.0 |  0.08
Output  | 0.00016935 | 0.00016935 | 0.00016935 |   0.0 |  0.00
Modify  | 0.35725    | 0.35725    | 0.35725    |   0.0 |  0.31
Other   |            | 0.0576     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.880026274405, Press = -0.211090306971924
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    149000  -13476.83      -13476.83      -13549.571     -13549.571      281.51442      281.51442      31302.794      31302.794     -324.718       -324.718      
    150000  -13475.67      -13475.67      -13548.582     -13548.582      282.17878      282.17878      31296.115      31296.115      434.5435       434.5435     
Loop time of 114.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.759 hours/ns, 8.747 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.82     | 113.82     | 113.82     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093736   | 0.093736   | 0.093736   |   0.0 |  0.08
Output  | 0.00017088 | 0.00017088 | 0.00017088 |   0.0 |  0.00
Modify  | 0.35745    | 0.35745    | 0.35745    |   0.0 |  0.31
Other   |            | 0.05831    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.878549791596, Press = -0.298366014710162
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    150000  -13475.67      -13475.67      -13548.582     -13548.582      282.17878      282.17878      31296.115      31296.115      434.5435       434.5435     
    151000  -13478.429     -13478.429     -13547.973     -13547.973      269.14413      269.14413      31260.249      31260.249      3351.0265      3351.0265    
Loop time of 130.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.297 hours/ns, 7.653 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.07     | 130.07     | 130.07     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10498    | 0.10498    | 0.10498    |   0.0 |  0.08
Output  | 0.00023314 | 0.00023314 | 0.00023314 |   0.0 |  0.00
Modify  | 0.43344    | 0.43344    | 0.43344    |   0.0 |  0.33
Other   |            | 0.06441    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.884750785298, Press = -0.608885904569849
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    151000  -13478.429     -13478.429     -13547.973     -13547.973      269.14413      269.14413      31260.249      31260.249      3351.0265      3351.0265    
    152000  -13473.791     -13473.791     -13545.644     -13545.644      278.07896      278.07896      31266.983      31266.983      3135.8474      3135.8474    
Loop time of 133.692 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.137 hours/ns, 7.480 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.08     | 133.08     | 133.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10712    | 0.10712    | 0.10712    |   0.0 |  0.08
Output  | 0.00016996 | 0.00016996 | 0.00016996 |   0.0 |  0.00
Modify  | 0.44378    | 0.44378    | 0.44378    |   0.0 |  0.33
Other   |            | 0.06548    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.896880134309, Press = -0.254911808513199
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    152000  -13473.791     -13473.791     -13545.644     -13545.644      278.07896      278.07896      31266.983      31266.983      3135.8474      3135.8474    
    153000  -13479.062     -13479.062     -13548.341     -13548.341      268.11675      268.11675      31267.849      31267.849      2681.4035      2681.4035    
Loop time of 133.421 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.061 hours/ns, 7.495 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    | 132.8      | 132.8      | 132.8      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10879    | 0.10879    | 0.10879    |   0.0 |  0.08
Output  | 0.00021334 | 0.00021334 | 0.00021334 |   0.0 |  0.00
Modify  | 0.44266    | 0.44266    | 0.44266    |   0.0 |  0.33
Other   |            | 0.06483    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.903873400651, Press = -0.0202548027339771
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    153000  -13479.062     -13479.062     -13548.341     -13548.341      268.11675      268.11675      31267.849      31267.849      2681.4035      2681.4035    
    154000  -13477.098     -13477.098     -13548.112     -13548.112      274.83245      274.83245      31272.981      31272.981      2338.2345      2338.2345    
Loop time of 113.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.606 hours/ns, 8.789 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.27     | 113.27     | 113.27     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093622   | 0.093622   | 0.093622   |   0.0 |  0.08
Output  | 0.0002088  | 0.0002088  | 0.0002088  |   0.0 |  0.00
Modify  | 0.35644    | 0.35644    | 0.35644    |   0.0 |  0.31
Other   |            | 0.05785    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.911363727312, Press = 0.057308286959433
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    154000  -13477.098     -13477.098     -13548.112     -13548.112      274.83245      274.83245      31272.981      31272.981      2338.2345      2338.2345    
    155000  -13478.376     -13478.376     -13548.785     -13548.785      272.4921       272.4921       31279.681      31279.681      1679.4169      1679.4169    
Loop time of 113.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.484 hours/ns, 8.823 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    | 112.84     | 112.84     | 112.84     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092844   | 0.092844   | 0.092844   |   0.0 |  0.08
Output  | 0.0015135  | 0.0015135  | 0.0015135  |   0.0 |  0.00
Modify  | 0.35399    | 0.35399    | 0.35399    |   0.0 |  0.31
Other   |            | 0.05849    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.917625406602, Press = 0.146126933792273
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    155000  -13478.376     -13478.376     -13548.785     -13548.785      272.4921       272.4921       31279.681      31279.681      1679.4169      1679.4169    
    156000  -13477.642     -13477.642     -13547.81      -13547.81       271.55828      271.55828      31296.904      31296.904      213.04648      213.04648    
Loop time of 113.247 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.457 hours/ns, 8.830 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    | 112.74     | 112.74     | 112.74     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092777   | 0.092777   | 0.092777   |   0.0 |  0.08
Output  | 0.00016819 | 0.00016819 | 0.00016819 |   0.0 |  0.00
Modify  | 0.35488    | 0.35488    | 0.35488    |   0.0 |  0.31
Other   |            | 0.05803    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.928106852287, Press = 0.0133178147822575
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    156000  -13477.642     -13477.642     -13547.81      -13547.81       271.55828      271.55828      31296.904      31296.904      213.04648      213.04648    
    157000  -13474.2       -13474.2       -13545.153     -13545.153      274.59561      274.59561      31305.811      31305.811     -77.375007     -77.375007    
Loop time of 113.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.486 hours/ns, 8.822 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    | 112.84     | 112.84     | 112.84     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093485   | 0.093485   | 0.093485   |   0.0 |  0.08
Output  | 0.00016767 | 0.00016767 | 0.00016767 |   0.0 |  0.00
Modify  | 0.35466    | 0.35466    | 0.35466    |   0.0 |  0.31
Other   |            | 0.05803    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127998 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.928866856903, Press = -0.0269120987850206
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    157000  -13474.2       -13474.2       -13545.153     -13545.153      274.59561      274.59561      31305.811      31305.811     -77.375007     -77.375007    
    158000  -13477.667     -13477.667     -13548.412     -13548.412      273.78834      273.78834      31302.744      31302.744     -318.90516     -318.90516    
Loop time of 113.681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.578 hours/ns, 8.797 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.17     | 113.17     | 113.17     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093262   | 0.093262   | 0.093262   |   0.0 |  0.08
Output  | 0.00016897 | 0.00016897 | 0.00016897 |   0.0 |  0.00
Modify  | 0.35522    | 0.35522    | 0.35522    |   0.0 |  0.31
Other   |            | 0.05791    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.932596400635, Press = -0.0706988470718072
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    158000  -13477.667     -13477.667     -13548.412     -13548.412      273.78834      273.78834      31302.744      31302.744     -318.90516     -318.90516    
    159000  -13475.448     -13475.448     -13547.301     -13547.301      278.08         278.08         31311.447      31311.447     -737.6089      -737.6089     
Loop time of 113.437 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.510 hours/ns, 8.815 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    | 112.93     | 112.93     | 112.93     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093384   | 0.093384   | 0.093384   |   0.0 |  0.08
Output  | 0.00016889 | 0.00016889 | 0.00016889 |   0.0 |  0.00
Modify  | 0.35411    | 0.35411    | 0.35411    |   0.0 |  0.31
Other   |            | 0.058      |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.935642630995, Press = -0.0856111249303958
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    159000  -13475.448     -13475.448     -13547.301     -13547.301      278.08         278.08         31311.447      31311.447     -737.6089      -737.6089     
    160000  -13476.286     -13476.286     -13547.48      -13547.48       275.52776      275.52776      31316.772      31316.772     -1237.7691     -1237.7691    
Loop time of 113.648 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.569 hours/ns, 8.799 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.14     | 113.14     | 113.14     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093015   | 0.093015   | 0.093015   |   0.0 |  0.08
Output  | 0.00019157 | 0.00019157 | 0.00019157 |   0.0 |  0.00
Modify  | 0.35436    | 0.35436    | 0.35436    |   0.0 |  0.31
Other   |            | 0.0583     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127990 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.936692955538, Press = -0.135222334014052
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    160000  -13476.286     -13476.286     -13547.48      -13547.48       275.52776      275.52776      31316.772      31316.772     -1237.7691     -1237.7691    
    161000  -13479.297     -13479.297     -13549.353     -13549.353      271.12631      271.12631      31308.269      31308.269     -754.61827     -754.61827    
Loop time of 113.551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.542 hours/ns, 8.807 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.05     | 113.05     | 113.05     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093183   | 0.093183   | 0.093183   |   0.0 |  0.08
Output  | 0.00016918 | 0.00016918 | 0.00016918 |   0.0 |  0.00
Modify  | 0.35463    | 0.35463    | 0.35463    |   0.0 |  0.31
Other   |            | 0.05795    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.928066101615, Press = -0.289610013041966
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    161000  -13479.297     -13479.297     -13549.353     -13549.353      271.12631      271.12631      31308.269      31308.269     -754.61827     -754.61827    
    162000  -13476.577     -13476.577     -13548.206     -13548.206      277.21196      277.21196      31293.583      31293.583      730.33185      730.33185    
Loop time of 113.399 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.500 hours/ns, 8.818 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    | 112.89     | 112.89     | 112.89     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092881   | 0.092881   | 0.092881   |   0.0 |  0.08
Output  | 0.00016857 | 0.00016857 | 0.00016857 |   0.0 |  0.00
Modify  | 0.35435    | 0.35435    | 0.35435    |   0.0 |  0.31
Other   |            | 0.05798    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127996 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.933683106282, Press = -0.493873305046633
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    162000  -13476.577     -13476.577     -13548.206     -13548.206      277.21196      277.21196      31293.583      31293.583      730.33185      730.33185    
    163000  -13478.243     -13478.243     -13548.277     -13548.277      271.03917      271.03917      31274.289      31274.289      2257.817       2257.817     
Loop time of 113.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.426 hours/ns, 8.839 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    | 112.63     | 112.63     | 112.63     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092514   | 0.092514   | 0.092514   |   0.0 |  0.08
Output  | 0.00020881 | 0.00020881 | 0.00020881 |   0.0 |  0.00
Modify  | 0.35453    | 0.35453    | 0.35453    |   0.0 |  0.31
Other   |            | 0.05796    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.932552514947, Press = -0.330794466002212
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    163000  -13478.243     -13478.243     -13548.277     -13548.277      271.03917      271.03917      31274.289      31274.289      2257.817       2257.817     
    164000  -13475.685     -13475.685     -13547.731     -13547.731      278.82393      278.82393      31287.158      31287.158      1326.0658      1326.0658    
Loop time of 113.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.485 hours/ns, 8.823 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    | 112.84     | 112.84     | 112.84     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093324   | 0.093324   | 0.093324   |   0.0 |  0.08
Output  | 0.0001682  | 0.0001682  | 0.0001682  |   0.0 |  0.00
Modify  | 0.35486    | 0.35486    | 0.35486    |   0.0 |  0.31
Other   |            | 0.05762    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.940030668825, Press = -0.102408718970542
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    164000  -13475.685     -13475.685     -13547.731     -13547.731      278.82393      278.82393      31287.158      31287.158      1326.0658      1326.0658    
    165000  -13477.23      -13477.23      -13547.738     -13547.738      272.87397      272.87397      31279.636      31279.636      1927.4341      1927.4341    
Loop time of 113.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.532 hours/ns, 8.809 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.01     | 113.01     | 113.01     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093607   | 0.093607   | 0.093607   |   0.0 |  0.08
Output  | 0.00016762 | 0.00016762 | 0.00016762 |   0.0 |  0.00
Modify  | 0.35383    | 0.35383    | 0.35383    |   0.0 |  0.31
Other   |            | 0.05807    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.940631264087, Press = -0.017499362868387
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    165000  -13477.23      -13477.23      -13547.738     -13547.738      272.87397      272.87397      31279.636      31279.636      1927.4341      1927.4341    
    166000  -13478.409     -13478.409     -13548.429     -13548.429      270.98522      270.98522      31280.852      31280.852      1460.2832      1460.2832    
Loop time of 113.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.500 hours/ns, 8.818 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    | 112.89     | 112.89     | 112.89     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093111   | 0.093111   | 0.093111   |   0.0 |  0.08
Output  | 0.00016994 | 0.00016994 | 0.00016994 |   0.0 |  0.00
Modify  | 0.35472    | 0.35472    | 0.35472    |   0.0 |  0.31
Other   |            | 0.05741    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127992 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.946342986584, Press = 0.124560274711485
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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    166000  -13478.409     -13478.409     -13548.429     -13548.429      270.98522      270.98522      31280.852      31280.852      1460.2832      1460.2832    
    167000  -13473.548     -13473.548     -13545.855     -13545.855      279.83489      279.83489      31302.597      31302.597      226.73863      226.73863    
Loop time of 113.492 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.526 hours/ns, 8.811 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    | 112.99     | 112.99     | 112.99     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093227   | 0.093227   | 0.093227   |   0.0 |  0.08
Output  | 0.00016881 | 0.00016881 | 0.00016881 |   0.0 |  0.00
Modify  | 0.35402    | 0.35402    | 0.35402    |   0.0 |  0.31
Other   |            | 0.05816    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       127994 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
31301.1140550696

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0